Nachdenken

Ein Modell, das in einem einzigen Durchgang antwortet, muss alles beim ersten Versuch 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" (Nachdenken) hebt diese Einschränkung auf. Wenn Nachdenken aktiv ist, arbeitet Claude das Problem in eigenen Worten durch, bevor es antwortet: Es formuliert neu, was gefragt wird, probiert Ansätze aus, prüft Zwischenergebnisse und verwirft Wege, die nicht tragen. Dieses Vorab-Nachdenken kommt in thinking-Content-Blöcken vor der Antwort an, und Claude stützt sich darauf, um die endgültige Antwort zu erstellen. Deshalb verbessert Nachdenken die Leistung bei komplexen Aufgaben wie Mathematik, Programmierung, Analyse und lang laufender agentischer Arbeit, bei denen die Qualität der Antwort von Zwischenarbeit abhängt, die sonst in die Antwort selbst komprimiert oder übersprungen würde.

Nachdenken hat seinen Preis: Die Token, die Claude für das Überlegen aufwendet, werden als Ausgabe-Token abgerechnet, auch wenn der Denktext nicht an dich zurückgegeben wird, und sie zählen zusammen mit dem Antworttext auf max_tokens. Diese Seite behandelt, wie sich Nachdenken über die gesamte API-Oberfläche hinweg verhält: wie du es einschaltest, seine Ausgabe liest und seine Wechselwirkungen mit Tools, Streaming, Caching und dem „context window“ (Kontextfenster) handhabst.

Wie Nachdenken funktioniert

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

So sieht Vorab-Nachdenken in einer Antwort aus: Ein oder mehrere thinking-Content-Blöcke kommen vor den text-Blöcken an. Der „thinking block" (Thinking-Block) ist weiterhin generierter Inhalt, wie der darauffolgende text-Block, wird aber von der eigentlichen Antwort getrennt. Jeder Thinking-Block enthält außerdem ein signature-Feld, eine verschlüsselte Kopie der vollständigen Schlussfolgerungen, 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 Überlegungen. Das Feld display in der Thinking-Konfiguration steuert, ob diese Zusammenfassung überhaupt zurückgegeben wird: "summarized" gibt sie zurück, während "omitted", der Standard bei vielen 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 Anzeige des Nachdenkens steuern für modellspezifische Standardwerte und Details.

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

Nachdenken konfigurieren

Bei den meisten Modellen ist Nachdenken standardmäßig aktiv oder nur einen Parameter entfernt. Die folgende Tabelle zeigt, was jedes Modell mit jedem thinking-Wert macht, den eine Anfrage senden kann. Ein 400-Fehler bedeutet, dass die API die Anfrage ablehnt, und Fehlerbehebung beim Nachdenken listet jeden Fehler und seine Lösung auf.

In der Tabelle bedeutet „bei Effort high oder niedriger", dass die Anfrage bei Effort low, medium und high funktioniert und bei xhigh oder max einen 400-Fehler zurückgibt.

Auf Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview und Claude Haiku 5.5 ist Nachdenken bereits aktiv und benötigt keine Konfiguration. display ist bei diesen Modellen standardmäßig "omitted", sodass der Thinking-Text verborgen bleibt, bis du dich dafür entscheidest. Aktiviere ihn mit thinking: {"type": "adaptive", "display": "summarized"}, wie es die folgenden Beispiele tun.

Auf Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6 und Claude Sonnet 4.6 ist Nachdenken deaktiviert, bis du thinking: {type: "adaptive"} setzt, wodurch Claude anhand der Anfrage selbst bestimmt, wann und wie tief es nachdenkt. Dieselbe Anfrage mit ausgetauschtem Modell-String schaltet es dort ein. Die folgenden Beispiele 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-5-5",
    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:
    match block.type:
        case "thinking":
            print(f"\nThinking: {block.thinking}")
        case "text":
            print(f"\nResponse: {block.text}")

Wenn du das Beispiel ausführst, wird zuerst das zusammengefasste Nachdenken und dann die Antwort ausgegeben:

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 den Wert hoch genug, um Platz für das Nachdenken und den Antworttext zu lassen. Siehe Kostenkontrolle auf der Steuerungsseite und Nachdenken und das Kontextfenster.

Nachdenken ausschalten

Auf Claude Sonnet 5, wo Nachdenken standardmäßig aktiv 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 Nachdenken ebenfalls standardmäßig aktiviert und akzeptiert thinking: {type: "disabled"} bei Effort high oder niedriger. Bei Effort xhigh oder max kann Nachdenken nicht ausgeschaltet werden: Anfragen, die thinking: {type: "disabled"} mit diesen Effort-Stufen kombinieren, geben einen 400-Fehler zurück. Diese Einschränkung wird bei jeder Anfrage durchgesetzt. Bei deaktiviertem Nachdenken kann Claude Opus 5 gelegentlich Tool-Aufrufe als reinen Text ausgeben oder interne XML-Tags in seine sichtbare Ausgabe aufnehmen. Siehe Betrieb mit deaktiviertem Nachdenken für Gegenmaßnahmen beim Prompting.

Claude Sonnet 5.5 hat Nachdenken ebenfalls standardmäßig aktiviert und lehnt thinking: {type: "disabled"} mit einem 400-Fehler ab. Um das Vorab-Nachdenken auszuschalten, sende stattdessen thinking: {type: "between_tools"}. Das ist die niedrigste Thinking-Einstellung auf Claude Sonnet 5.5, und sie wird bei Effort high oder niedriger akzeptiert. Das Modell gibt weiterhin seine Fortschrittsmeldungen zwischen Tool-Aufrufen zurück. Ohne Tools enthält die Antwort nur Text, wie bei disabled auf Claude Sonnet 5. Siehe Ausführung ohne vorgelagertes Nachdenken für Hinweise zum Prompting.

Claude Haiku 5.5 hat Nachdenken ebenfalls standardmäßig aktiviert und akzeptiert thinking: {type: "disabled"} bei Effort high oder niedriger. Bei Effort xhigh oder max gibt diese Kombination einen 400-Fehler zurück. Um weniger Nachdenken zu erhalten, senke zuerst die Effort-Stufe. Bei ausgeschaltetem Nachdenken kann das Modell einen benötigten Tool-Aufruf überspringen, wenn du zusätzlich JSON-Ausgabe anforderst. Ein output_config.effort pro Nachricht, das von der aktuell geltenden Stufe abweicht, gibt bei ausgeschaltetem Nachdenken ebenfalls einen 400-Fehler zurück. Siehe Effort zur Steuerung des Nachdenkens verwenden und Adaptives Nachdenken mit JSON-Ausgabe und deinen eigenen Tools verwenden.

Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5 und Claude Mythos Preview lehnen thinking: {type: "disabled"} ab. Nachdenken kann auf diesen Modellen nicht ausgeschaltet werden.

Um vor dem Senden einer Anfrage zu prüfen, ob ein Modell "disabled" akzeptiert, lies seinen Wert capabilities.thinking.types.disabled.supported aus der Models API. Die Models API verwenden beschreibt das Feld.

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

Denkausgabe lesen

Anzeige des Nachdenkens steuern

Das Feld display 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 diese Werte:

• "summarized": Thinking-Blöcke enthalten zusammengefassten Thinking-Text, eine lesbare Zusammenfassung von Claudes Schlussfolgerungen. Dies ist der Standard auf 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 enthält weiterhin das verschlüsselte vollständige Nachdenken für die Multi-Turn-Kontinuität (siehe Thinking-Verschlüsselung). Dies ist der Standard auf Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Mythos Preview und Claude Haiku 5.5.
• "updates" (Beta): Reasoning-Blöcke werden wie bei "omitted" mit einem leeren thinking-Feld zurückgegeben, und die kurzen Fortschrittsmeldungen, die manche Modelle zwischen Tool-Aufrufen schreiben, kommen als lesbarer Text zurück. Erfordert den Beta-Header thinking-display-updates-2026-08-18.

Setze display: "omitted", wenn deine Anwendung Thinking-Inhalte nicht für Benutzer anzeigt. Der Hauptvorteil ist eine schnellere Zeit bis zum ersten Text-Token beim Streaming: Der Server überspringt das Streaming der Thinking-Token vollständig und liefert nur die Signatur, sodass das Streaming der endgültigen Textantwort früher 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, wenn du mit ausgelassenem Nachdenken arbeitest:

• 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 Nachdenken für die Prompt-Erstellung zu rekonstruieren (siehe Thinking-Blöcke beibehalten). Jeglicher Text, den du in das thinking-Feld eines zurückgegebenen ausgelassenen Blocks einfügst, wird ignoriert.
• display ist ungültig mit thinking.type: "disabled" (es gibt nichts anzuzeigen) und mit thinking.type: "between_tools" (nur Claude Sonnet 5.5), das kein weiteres Feld akzeptiert. Mit between_tools kommen Fortschrittsmeldungen weiterhin mit Zusammenfassungstext zurück, wie unter display: "updates" (siehe Fortschrittsmeldungen).
• Wenn du thinking.type: "adaptive" verwendest und das Modell das Nachdenken bei einer einfachen Anfrage überspringt, wird unabhängig von display kein Thinking-Block erzeugt.
• Beim Streaming mit display: "omitted" wird kein Thinking-Text gestreamt. Jeder Thinking-Block streamt ein thinking_delta mit einem leeren thinking-String, gefolgt von seinem signature_delta. Mit display: "updates" streamen nur Fortschrittsmeldungs-Blöcke thinking_delta-Events, die Text enthalten. Siehe Nachdenken streamen für die Event-Abfolge.

Zusammengefasstes Nachdenken

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

Beachte Folgendes, wenn du mit zusammengefasstem Nachdenken arbeitest:

• Dir werden die vollständigen Thinking-Token berechnet, die durch die ursprüngliche Anfrage erzeugt wurden, nicht die Token der Zusammenfassung. Die abgerechnete Anzahl an Output-Token stimmt nicht mit der Anzahl der Token überein, die du in der Antwort siehst.
• Auf Claude Opus 4.6, Claude Sonnet 4.6 und früheren Modellen sind die ersten Zeilen der Thinking-Ausgabe ausführlicher und liefern detaillierte Überlegungen, die besonders für Prompt-Engineering-Zwecke hilfreich sind. Claude Mythos Preview fasst ab dem ersten Token zusammen, daher zeigen seine Thinking-Blöcke diese ausführliche Einleitung nicht.
• Die Zusammenfassung bewahrt die Kernideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz, sodass Zusammenfassungen gestreamt werden können, sobald sie eintreffen.
• Die Zusammenfassung wird von einem anderen Modell verarbeitet als dem, das du in deinen Anfragen ansprichst. Das denkende Modell sieht die zusammengefasste Ausgabe nicht.
• Da Anthropic bestrebt ist, die Thinking-Funktion zu verbessern, kann sich das Verhalten der Zusammenfassung ändern.

Um die Schlussfolgerungen des Modells zu sehen, lies die thinking-Blöcke, anstatt im Antworttext nach Schlussfolgerungen zu fragen. Auf Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 und Claude Fable 5 kann eine Anfrage, die versucht, die internen Schlussfolgerungen des Modells als Teil des Antworttexts hervorzulocken, mit stop_details.category: "reasoning_extraction" abgelehnt werden. Siehe Ablehnungskategorien für die Feldreferenz und Reasoning in Thinking-Blöcken belassen dafür, worum du stattdessen bitten solltest.

Nachdenken streamen

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

Die folgenden Beispiele streamen eine Antwort mit adaptivem Nachdenken und geben Thinking- und Text-Deltas aus, sobald sie eintreffen:

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-opus-5-5",
    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:
        match event.type:
            case "content_block_start":
                print(f"\nStarting {event.content_block.type} block...")
            case "content_block_delta":
                delta = event.delta
                match delta.type:
                    case "thinking_delta":
                        print(delta.thinking, end="", flush=True)
                    case "text_delta":
                        print(delta.text, end="", flush=True)

Um vollständige Thinking-Blöcke mit ihren Signaturen nach dem Streaming wieder zusammenzusetzen, verwende den Hilfsmechanismus deines SDK zum Akkumulieren von Nachrichten, stream.get_final_message(), anstatt Deltas selbst zu verketten.

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-opus-5-5", "stop_reason": null, "stop_sequence": null}}

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": "thinking_delta", "thinking": "I need to find the GCD of 1071 and 462 using the Euclidean algorithm.\n\n1071 = 2 × 462 + 147"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n462 = 3 × 147 + 21\n147 = 7 × 21 + 0\n\nSo GCD(1071, 462) = 21"}}

// Additional thinking deltas...

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

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": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "The greatest common divisor of 1071 and 462 is **21**."}}

// Additional text deltas...

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

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

Wenn display: "omitted" gesetzt ist, öffnet sich der Thinking-Block, ein thinking_delta mit einem leeren thinking-String trifft ein, ein einzelnes signature_delta folgt, und der Block schließt sich. 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":"thinking_delta","thinking":""}}

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":""}}

Mit display: "updates" (Beta) werden Reasoning-Blöcke so gestreamt wie unter "omitted". Jeder Fortschrittsmeldungs-Block streamt seinen Text als thinking_delta-Events vor dem tool_use-Block, den er einleitet. Eine Pause von mehreren Sekunden, bevor sich der Fortschrittsmeldungs-Block öffnet, ist normal:

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

event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call."}}

event: content_block_delta
data: {"type":"content_block_delta","index":1,"delta":{"type":"signature_delta","signature":"Es8CCkYICxIM..."}}

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

event: content_block_start
data: {"type":"content_block_start","index":2,"content_block":{"type":"tool_use","id":"toolu_01D7FLrfh4GYq7yT1ULFeyMV","name":"edit_file","input":{}}}

Behandle unter "updates" einen Block als Fortschrittsmeldung, sobald eines seiner thinking_delta-Events nicht-leeren Text enthält.

Allgemeine Streaming-Mechanismen findest du unter Streaming von Nachrichten.

Nachdenken und Effort

Der Parameter thinking steuert, ob Claude vor dem Antworten in Thinking-Blöcken nachdenkt; der Parameter effort steuert, wie viel Arbeit Claude in die gesamte Antwort steckt, was im adaptiven Modus auch umfasst, wie oft und wie tief es nachdenkt. Übergib adaptive nicht als effort-Wert: adaptive ist ein Denkmodus, keine Effort-Stufe.

Um zu erfahren, was jede Effort-Stufe mit dem Thinking-Verhalten macht, siehe die Tabelle zum Thinking-Verhalten pro Stufe auf der Seite Nachdenken steuern. Die Seite Effort dokumentiert den Parameter selbst, einschließlich der Stufen, die jedes Modell unterstützt. Auf Claude Opus 4.5, dem einzigen Modell mit ausschließlich erweitertem Nachdenken, das Effort unterstützt, wirkt Effort zusammen mit budget_tokens. Siehe Budgetregeln und Abstimmung.

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

• Geringere Kosten oder Latenz bei einer Workload mit aktiviertem Nachdenken: Senke zuerst effort. Es skaliert die gesamte Antwort herunter, einschließlich des Nachdenkens.
• Claude denkt zu selten oder zu oberflächlich nach: Erhöhe effort oder siehe Steuern, wie oft Claude nachdenkt auf der Steuerungsseite.
• Du brauchst Nachdenken vollständig ausgeschaltet: Verwende thinking: {type: "disabled"} auf Modellen, die dies erlauben (siehe die modellspezifische Konfigurationstabelle). Claude Sonnet 5.5 lehnt "disabled" ab. Seine niedrigste Einstellung ist thinking: {type: "between_tools"}, die das Vorab-Nachdenken ausschaltet.
• Du brauchst eine harte Obergrenze für die Ausgaben: Verwende max_tokens. Effort ist eine weiche Vorgabe. max_tokens ist ein striktes Limit.

Nachdenken mit Tool-Nutzung

Nachdenken funktioniert zusammen mit „tool use" (Tool-Nutzung) und ermöglicht es Claude, die Tool-Auswahl zu durchdenken und Tool-Ergebnisse zu verarbeiten. Es gelten zwei Einschränkungen:

1. Einschränkung der Tool-Auswahl (manueller Modus): Tool-Nutzung mit manuellem erweitertem Nachdenken (thinking: {type: "enabled"}) unterstützt nur tool_choice: {"type": "auto"} (den Standard) oder tool_choice: {"type": "none"}. Die Verwendung von tool_choice: {"type": "any"} oder tool_choice: {"type": "tool", "name": "..."} führt zu einem Fehler, da diese Optionen die Tool-Nutzung erzwingen, was mit manuellem erweitertem Nachdenken nicht kompatibel ist. Adaptives Nachdenken, auch bei Modellen, bei denen Nachdenken standardmäßig aktiviert ist, unterstützt erzwungene Tool-Nutzung, außer bei Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 und Claude Mythos 5.1 (siehe Response-Prefill und erzwungene Tool-Nutzung). Wo erzwungene Tool-Nutzung akzeptiert wird, beginnt die Antwort mit dem Tool-Aufruf und hat keinen thinking-Block.
2. Thinking-Blöcke beibehalten: 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 beibehalten.

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 Abfolge ist ein einziger 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 Nachdenken 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 Anfrage mit aktiviertem Nachdenken mit einem Thinking-Block beginnt. Der adaptive Modus lockert dies: Kein Assistant-Turn muss mit einem solchen beginnen.

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

Schalte zwischen Turns um, nicht innerhalb von Turns. Plane deine Thinking-Strategie zu Beginn jedes Turns. Schließe den Assistant-Turn ab und ändere dann 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 macht außerdem das „prompt caching" (Prompt-Caching) ungültig. Siehe Nachdenken und Prompt-Caching.

Thinking-Blöcke beibehalten

Wenn Claude ein Tool aufruft, pausiert es den Aufbau seiner Antwort, um auf externe Informationen zu warten. Wenn du das Tool-Ergebnis zurückgibst, baut Claude dieselbe Antwort weiter auf, daher müssen seine früheren Überlegungen noch vorhanden sein. 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. Kontinuität der Überlegungen: Die Thinking-Blöcke erfassen die schrittweisen Überlegungen, die zu den Tool-Anfragen geführt haben. Sie einzubeziehen lässt Claude dort weiterdenken, wo es aufgehört hat.
2. Kontexterhalt: Tool-Ergebnisse erscheinen in der API-Struktur als User-Nachrichten, sind aber Teil eines durchgehenden Gedankenflusses. Das Beibehalten der Thinking-Blöcke erhält diesen Fluss über API-Aufrufe hinweg.

Kurz gesagt:

• Erforderlich: Innerhalb eines Tool-Use-Turns Thinking-Blöcke zurückgeben.
• Empfohlen: Über Turns hinweg alles zurückgeben.
• Erlaubt: Außerhalb der Tool-Nutzung das Nachdenken früherer Turns weglassen.

Du musst altes Nachdenken nicht selbst ausdünnen. Gib in Multi-Turn-Gesprächen alle Thinking-Blöcke zurück, und die API filtert sie automatisch, behält die Blöcke, die zum Erhalt der Überlegungen des Modells nötig sind, und berechnet Eingabe-Token nur für die Blöcke, die Claude tatsächlich gezeigt werden. Welche Blöcke früherer Turns behalten werden, ist modellabhängig. Siehe Thinking-Block-Erhaltung nach Modell. Um den Standard zu überschreiben, verwende die Context-Editing-Strategie clear_thinking_20251015.

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

Eine vollständige Schritt-für-Schritt-Anleitung über zwei Turns mit Code in jedem SDK findest du unter Nachdenken in Tool- und Multi-Turn-Workflows. Sie definiert ein Tool, empfängt eine Antwort mit Nachdenken plus Tool-Nutzung und gibt den Assistant-Turn zusammen mit dem Tool-Ergebnis zurück.

Verschachteltes Nachdenken

„Interleaved thinking" (verschachteltes Nachdenken) ermöglicht es Claude, zwischen Tool-Aufrufen nachzudenken und jedes Tool-Ergebnis zu durchdenken, bevor es darauf reagiert. Mit verschachteltem Nachdenken kann Claude:

• Die Ergebnisse eines Tool-Aufrufs durchdenken, bevor es entscheidet, was als Nächstes zu tun ist
• Mehrere Tool-Aufrufe mit dazwischenliegenden Denkschritten verketten
• Differenziertere Entscheidungen auf Basis von Zwischenergebnissen treffen

Mit adaptivem Nachdenken ist verschachteltes Nachdenken auf jedem Modell, das adaptives Nachdenken unterstützt, automatisch aktiv. Es ist kein Beta-Header erforderlich. Auf Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Opus 4.8 und Claude Opus 4.7 erscheinen Schlussfolgerungen zwischen Tool-Aufrufen immer in Thinking-Blöcken. Claude Haiku 4.5 unterstützt kein verschachteltes Nachdenken. Auf Modellen mit manuellem erweitertem Nachdenken erfordert die Verschachtelung einen Beta-Header und ändert, wie das Thinking-Budget gezählt wird. Verschachteltes Nachdenken im manuellen Modus behandelt die modellspezifischen Regeln und das plattformspezifische Header-Verhalten.

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

Einen ausgearbeiteten Vergleich, der zeigt, was verschachteltes Nachdenken in einem Workflow mit zwei Tools ändert, findest du unter Wie verschachteltes Nachdenken den Ablauf verändert.

Fortschrittsmeldungen zwischen Tool-Aufrufen

Auf Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Fable 5 kann das Modell zwischen Tool-Aufrufen eine Fortschrittsmeldung schreiben. Eine Fortschrittsmeldung ist eine Notiz darüber, was das Modell gerade herausgefunden hat und was es als Nächstes tun wird, geschrieben für die Person, die den Agenten beobachtet, und nicht als Schlussfolgerung. Jede kommt als eigener thinking-Block mit eigener signature zurück, getrennt von jedem Reasoning-Block an derselben Stelle. Sie steht unmittelbar vor dem tool_use- oder server_tool_use-Block, den sie einleitet. Jedem Tool-Aufruf geht höchstens eine Fortschrittsmeldung voraus, und das Modell kann jede davon überspringen. Fortschrittsmeldungen sind kein verschachteltes Nachdenken: Sie erscheinen unabhängig davon, ob Reasoning-Blöcke zwischen Tool-Aufrufen erscheinen, und eine Antwort kann beides enthalten.

Was ein Fortschrittsmeldungs-Block enthält, hängt von display ab:

Auf Claude Sonnet 5.5 ist die niedrigste Thinking-Einstellung thinking: {type: "between_tools"}. Sie schaltet das Vorab-Nachdenken aus, und jede Fortschrittsmeldung kommt mit ihrem Zusammenfassungstext zurück, wie sie es unter display: "updates" tun würde. between_tools wird nur bei Effort high oder niedriger akzeptiert. Bei xhigh oder max gibt eine Anfrage damit einen 400-Fehler zurück. between_tools akzeptiert kein weiteres Feld: display, budget_tokens oder block_binding, die damit gesendet werden, führen zu einem 400-Fehler. Die Einstellung benötigt keinen Beta-Header und funktioniert auf jeder Plattform, die Claude Sonnet 5.5 anbietet. Gib die Blöcke unverändert zurück: Ein Fortschrittsmeldungs-Block, den du zurücksendest, gibt dem Modell die vollständige Notiz, die es geschrieben hat, nicht die Zusammenfassung.

Verwende display: "updates" für eine Agenten-Oberfläche, die Überlegungen verborgen hält und dem Benutzer bei jedem Schritt eine Statuszeile anzeigt. Dabei ist jeder thinking-Block mit nicht-leerem Text eine Fortschrittsmeldung, also rendere diese und nichts anderes. Die Einstellung befindet sich in der Beta und erfordert den Beta-Header thinking-display-updates-2026-08-18 (um ihn auf Amazon Bedrock, Google Cloud oder Microsoft Foundry zu senden, siehe Beta-Funktionen auf anderen Plattformen). Ohne ihn wird der Wert mit demselben 400-invalid_request_error abgelehnt wie ein unbekannter display-Wert.

{
  "model": "claude-fable-5-1",
  "max_tokens": 16000,
  "thinking": { "type": "adaptive", "display": "updates" },
  "tools": [
    {
      "name": "edit_file",
      "description": "Replace the contents of a file in the repository.",
      "input_schema": {
        "type": "object",
        "properties": {
          "path": { "type": "string" },
          "content": { "type": "string" }
        },
        "required": ["path", "content"]
      }
    }
  ],
  "messages": [
    {
      "role": "user",
      "content": "The login test fails after an hour of uptime. Find out why and fix it."
    }
  ]
}

Unter "updates" sieht der Anfang der Antwort, die auf ein tool_result folgt, so aus. Der erste Block ist eine Überlegung und bleibt leer, wie er es unter "omitted" wäre. Der zweite enthält Text, also ist er eine Fortschrittsmeldung. Unter "summarized" enthalten beide Blöcke Text, und unter "omitted" sind beide leer.

{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EqMBCkYICxIM..."
    },
    {
      "type": "thinking",
      "thinking": "Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call.",
      "signature": "Es8CCkYICxIM..."
    },
    {
      "type": "tool_use",
      "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV",
      "name": "edit_file",
      "input": { "path": "auth.py", "content": "..." }
    }
  ]
}

Beachte Folgendes, wenn du mit Fortschrittsmeldungen arbeitest:

• Gib Fortschrittsmeldungs-Blöcke unverändert mit dem Rest des Assistant-Turns zurück, wie jeden anderen thinking-Block.
• Der Text, den du erhältst, ist eine Zusammenfassung der Fortschrittsmeldung, normalerweise ein oder zwei Sätze. Verlasse dich nicht auf seine Länge. Die Fortschrittsmeldung zählt in voller Länge zu usage.output_tokens, nicht in der Länge der Zusammenfassung.
• Ein Fortschrittsmeldungs-Block kann unter jedem display-Wert mit einem leeren thinking-Feld zurückkommen. Rendere für einen leeren Block nichts. Unter "updates" sieht er genauso aus wie ein leerer Reasoning-Block und erfordert keine gesonderte Behandlung.
• Wenn eine Antwort kurz nach einem Tool-Aufruf oder Tool-Ergebnis mit max_tokens, model_context_window_exceeded oder stop_sequence endet, kann ihr letzter Block ein Fortschrittsmeldungs-Block sein, der für die Arbeit steht, die das Modell nicht abgeschlossen hat. Unter "updates" und "summarized" lautet sein Text genau This part of the response was interrupted before it finished., und du kannst ihn wie jede andere Meldung anzeigen. Unter "omitted" ist er leer. Um fortzufahren, gib den Assistant-Turn unverändert zurück und hänge eine neue user-Nachricht an (mit einem tool_result für jeden tool_use-Block in diesem Turn).
• Rechne beim Streaming mit einer Pause von mehreren Sekunden, bevor sich ein Fortschrittsmeldungs-Block öffnet. Siehe den "updates"-Trace unter Nachdenken streamen.
• Diese Modelle schreiben bei höherem Effort und in langen Tool-Ketten weniger Fortschrittsmeldungen. Wenn deine Oberfläche davon abhängt, siehe Nutzerseitige Fortschritts-Updates anfordern oder, für Claude Opus 5.5, Fortschrittsmeldungen für Benutzer. Für Claude Sonnet 5.5 siehe Fortschrittsupdates für Nutzer.

Thinking-Block-Erhaltung nach Modell

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

• Alle vorherigen Turns behalten: Claude Opus 4.5 und spätere Opus-Modelle, Claude Sonnet 4.6 und spätere Sonnet-Modelle, Claude Haiku 5.5, Claude Fable 5.1, Claude Mythos 5.1, 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 Erhaltung bringt zwei Vorteile:

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

Der Kompromiss ist die Kontextnutzung: Lange Gespräche verbrauchen auf Modellen, die alles behalten, mehr Kontextplatz, da beibehaltene Thinking-Blöcke wie jeder andere Gesprächsverlauf als Eingabe zählen (siehe Nachdenken und das Kontextfenster). Das Verhalten ist in beiden Regimen automatisch. Es sind keine Codeänderungen oder Beta-Header erforderlich, und du solltest weiterhin vollständige, unveränderte Thinking-Blöcke zurückgeben, wie in Thinking-Blöcke beibehalten beschrieben. Um den Standard in eine der beiden Richtungen zu überschreiben, verwende das Löschen von Thinking-Blöcken.

Modellwechsel mitten im Gespräch. Gib Thinking-Blöcke weiterhin unverändert zurück, wenn du das Modell wechselst, zum Beispiel nach einem Fallback bei Klassifikator-Ablehnung. Ein Thinking-Block ist nur für das Modell lesbar, das ihn erzeugt hat, sowie für bestimmte andere Modelle, und die API ignoriert oder verwirft die Blöcke, die das Zielmodell nicht lesen kann. Bei Claude Fable 5.1 und Claude Mythos 5.1 spielt die Richtung eine Rolle: Sie lesen die Thinking-Blöcke früherer Modelle, und nur diese beiden lesen gegenseitig ihre Blöcke. Ein Wechsel zu ihnen behält also das Reasoning des Gesprächs bei, und ein Wechsel von ihnen zu einem anderen Modell verwirft es (siehe wie verworfene Blöcke abgerechnet und gemeldet werden). Claude Opus 5.5 liest die Thinking-Blöcke von Claude Opus 5 und die früherer Opus-, Sonnet- und Haiku-Modelle sowie, auf der Claude API und Google Cloud, die von Claude Haiku 5.5, aber nicht die der Claude Fable- und Claude Mythos-Modelle; auf der Claude API lesen Claude Fable 5.1 und Claude Mythos 5.1 die Blöcke von Claude Opus 5.5. Ein Wechsel von Claude Opus 5.5 zu Claude Fable 5.1 auf der Claude API behält das Reasoning der früheren Turns bei; ein Wechsel von Claude Fable 5.1 zu Claude Opus 5.5 verwirft es. Claude Sonnet 5.5 liest Thinking-Blöcke von Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 und früheren Modellen sowie, auf der Claude API und Google Cloud, von Claude Haiku 5.5, aber nicht von Claude Opus 5, Claude Opus 5.5 oder einem Claude Fable- oder Claude Mythos-Modell. Auf der Claude API und Google Cloud liest Claude Opus 5.5 die Blöcke von Claude Sonnet 5.5, und kein anderes Modell tut dies: Ein Wechsel von Claude Sonnet 5.5 zu Claude Opus 5.5 auf der Claude API und Google Cloud behält das Reasoning der früheren Turns bei, und jeder andere Wechsel weg von Claude Sonnet 5.5 verwirft es. Claude Haiku 5.5 liest Thinking-Blöcke von Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5 und früheren Modellen, aber nicht von Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5 oder einem Claude Fable- oder Claude Mythos-Modell. Auf der Claude API und Google Cloud lesen Claude Opus 5.5 und Claude Sonnet 5.5 die Blöcke von Claude Haiku 5.5, und kein anderes Modell tut dies. Entferne vorherige thinking- und redacted_thinking-Blöcke nur dann selbst, wenn du auf Modellen, die sie ignorieren statt verwerfen, Eingabe-Token sparen willst, und niemals, wenn du eine Fallback-Gutschrift einlöst, da dies einen unveränderten Body erfordert.

Erhaltenes Nachdenken

Erhaltenes Nachdenken bestimmt, ob das Modell einen Thinking-Block verwenden kann, den du aus einem früheren Turn zurücksendest. Ab Claude Fable 5.1 prüft die API die signature jedes thinking- oder redacted_thinking-Blocks in einer Anfrage auf zwei Dinge:

• Das Modell, das ihn erzeugt hat. Jedes Modell liest seine eigenen Thinking-Blöcke und die einer festen Gruppe anderer Modelle. Claude Fable 5.1 liest Blöcke von Claude Opus 5 und, auf der Claude API, von Claude Opus 5.5; weder Claude Opus 5 noch Claude Opus 5.5 liest Blöcke von Claude Fable 5.1. Die API verwirft einen Block, den das aktuelle Modell nicht lesen kann, ohne Fehler und ohne ihn abzurechnen. Siehe Modellwechsel mitten im Gespräch.
• Alles, was davor gesendet wurde. Ein Block bleibt nur gültig, solange der system-Prompt auf oberster Ebene, die tools und die Nachrichten davor unverändert sind. Wenn sich eines davon ändert, sind dieser Block und jeder spätere Thinking-Block ungültig, und die API lehnt die Anfrage mit einem 400-Fehler ab oder verwirft die ungültigen Blöcke, je nachdem, was du wählst. Siehe Das Präfix unverändert lassen.

Thinking-Blöcke von Claude Sonnet 5.5 und Claude Haiku 5.5 sind außerdem an das Konto gebunden, das sie erzeugt hat. Siehe Thinking-Blöcke bleiben bei dem Konto, das sie erzeugt hat, um zu erfahren, wo die API dies durchsetzt.

Die Modellprüfung gilt für jedes Konto. Die API setzt die Präfixprüfung standardmäßig für Konten durch, die am oder nach dem 31. August 2026, 00:00 UTC, erstellt wurden. Bei älteren Konten setzt sie die Prüfung nur bei Anfragen durch, die thinking.block_binding.prefix_mismatch_behavior setzen. Gestalte deine Integration unabhängig vom Alter deines Kontos so, dass sie nur anhängt („append-only“), damit derselbe Code auf jedem Konto funktioniert, einschließlich neuerer Konten, bei denen die Prüfung standardmäßig durchgesetzt wird.

Um das Nachdenken gültig zu halten, sende jeden Assistant-Turn genau so zurück, wie du ihn erhalten hast, und füge neue Nachrichten nur am Ende von messages hinzu. Wenn dein Code das messages-Array selbst aufbaut, behandelt die Seite zu erhaltenem Nachdenken:

• Was als Bearbeitung zählt und wie du prüfst, ob dein Code eine vornimmt.
• Das API-Feature, das jede gängige Bearbeitung ersetzt: System-Nachrichten mitten in der Konversation für neue Anweisungen und Erinnerungen pro Turn, tool_addition- und tool_removal-Blöcke für Tool-Änderungen, output_config pro Nachricht für Effort-Änderungen sowie serverseitige Compaction und Kontextbearbeitung zum Kürzen.
• Clientseitige Compaction: welche Muster das Nachdenken gültig halten und welche nicht.
• Der Beta-Header thinking-binding-controls-2026-08-01. Er fügt der Thinking-Konfiguration ein Feld block_binding.prefix_mismatch_behavior ("error" oder "drop_block") und jeder Antwort ein input_transformations-Array hinzu. Das Array listet jeden Thinking-Block auf, den die API verworfen hat oder der die Präfixprüfung nicht bestanden hat und durchgelassen wurde.

Nachdenken und Prompt-Caching

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

Konfigurationsänderungen machen das Caching ungültig. Die Thinking-Konfiguration und die aufgelöste effort-Stufe werden in den Prompt selbst gerendert, sodass jede Änderung daran ein neues Cache-Präfix beginnt. Das Wechseln zwischen adaptive, enabled und disabled, das Ändern von budget_tokens und das Ändern des Effort-Werts machen alle Cache-Breakpoints ungültig: 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 Änderung am Nachdenken oder am Effort auf oberster Ebene so, als würde der Cache neu beginnen. Auf Modellen, die Effort pro Nachricht unterstützen, lässt eine Effort-Änderung, die in einer role: "system"-Nachricht innerhalb von messages übermittelt wird, das gecachte Präfix intakt. Aufeinanderfolgende Anfragen mit derselben Konfiguration erhalten den Cache, und das explizite Setzen eines Parameters auf seinen Standardwert ist gleichbedeutend mit dem Weglassen. Ein Thinking-Block, den die API unter einer beliebigen Bedingung für erhaltenes Nachdenken verwirft, ändert das gecachte Präfix ab der Position dieses Blocks. Unverändert zurückgegebene Blöcke halten den Cache intakt. Eine ausgearbeitete Demonstration mit Usage-Ausgabe findest du auf der Seite Nachdenken 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 Gesprächsverlauf einschließlich seiner Thinking-Blöcke gecacht werden, und diese gecachten Thinking-Blöcke zählen in deinen Nutzungsmetriken als Eingabe-Token, wenn sie aus dem Cache gelesen werden. Dies geschieht automatisch, auch ohne explizite cache_control-Markierungen, und verhält sich bei regulärem und verschachteltem Nachdenken gleich. Der Kompromiss: Thinking-Blöcke, die du in Antworten nie wieder siehst, tragen dennoch zur Nutzung von Eingabe-Token bei, wenn sie aus dem Cache gelesen werden.

Ob vorherige Blöcke überhaupt im Kontext sind, hängt vom Modell ab. Der Erhaltungsstandard regelt dies. Auf Modellen, die alles behalten, bleiben die Thinking-Blöcke vorheriger Turns gecacht und im Kontext. Auf Modellen, die nur den letzten Turn behalten, werden alle vorherigen Thinking-Blöcke aus dem Kontext entfernt, sobald du eine Benutzernachricht sendest, die kein Tool-Ergebnis ist. Auf 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 vorhanden 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]

Auf Modellen, die alles behalten, behält dieselbe Anfrage thinking_block_1 und thinking_block_2 im Kontext und im Cache.

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

Nachdenken und das Kontextfenster

max_tokens, das alles Nachdenken umfasst, das Claude im aktuellen Turn generiert, wird als strikte Grenze durchgesetzt. Auf Claude 4.5-Modellen und neuer akzeptiert die API die Anfrage, wenn Eingabe-Token plus max_tokens die Größe des Kontextfensters überschreiten. Wenn die Generierung dann die Grenze des Kontextfensters erreicht, stoppt sie mit stop_reason: "model_context_window_exceeded", anstatt einen Fehler zurückzugeben. Auf früheren Modellen gibt die API stattdessen einen Validierungsfehler zurück. Siehe Umgang mit Stop-Gründen.

Wie das Nachdenken auf das Fenster angerechnet wird, hängt davon ab, wann es generiert wurde:

• Nachdenken im aktuellen Turn zählt immer zu max_tokens, wird als Ausgabe-Token abgerechnet und belegt Platz im Kontextfenster für den Turn, der es generiert hat.
• Nachdenken aus vorherigen Turns hängt vom Erhaltungsstandard ab. Auf Modellen, die alle vorherigen Turns behalten, bleiben vorherige Thinking-Blöcke im Kontext, zählen zum Fenster und werden wie der Rest des Gesprächsverlaufs als Eingabe-Token abgerechnet. Auf Modellen, die nur den letzten Turn behalten, entfernt die API ältere Thinking-Blöcke automatisch, wenn du sie zurückgibst, sodass sie weder Fensterplatz noch Eingabe-Token verbrauchen.

In der Praxis:

• Plane auf Modellen, die alles behalten, dein Kontextfenster so, als wäre das Nachdenken gewöhnlicher Gesprächsverlauf, denn das ist es. Lange agentische Sitzungen sammeln Nachdenken im Kontext an. Verwende das Löschen von Thinking-Blöcken, wenn du Platz zurückgewinnen musst.
• Auf Modellen, die nur den letzten Turn behalten, sind die Kosten des Nachdenkens nur pro Turn: Das Nachdenken jedes Turns zählt gegen das max_tokens dieses Turns und fällt dann aus dem Fenster heraus.

Die folgenden Diagramme veranschaulichen das Regime, bei dem nur der letzte Turn behalten wird (Entfernen). Das erste zeigt eine Multi-Turn-Konversation: Der Thinking-Block jedes Turns wird in der Ausgabe generiert, aber nicht in die Eingabe späterer Turns übernommen.

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

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

Thinking-Verschlüsselung

Der vollständige Thinking-Inhalt wird verschlüsselt und im Feld signature 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, wenn du mit Signaturen arbeitest:

• Es ist nur dann zwingend 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 doch zurückgibst, hängt es vom Modell ab, ob die API sie behält oder entfernt (siehe Thinking-Block-Erhaltung nach Modell). Verwende Kontextbearbeitung, um dies zu konfigurieren.
• Wenn du Thinking-Blöcke zurücksendest, gib alles genau so zurück, wie du es erhalten hast, aus Konsistenzgründen und um potenzielle Probleme zu vermeiden.
• Beim Streaming 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 Feld signature ist opak: Interpretiere oder parse es nicht.
• signature-Werte sind plattformübergreifend kompatibel (die Claude API, Amazon Bedrock und Google Cloud). Auf einer Plattform erzeugte Werte funktionieren auf einer anderen, mit der Ausnahme, dass Thinking-Blöcke von Claude Sonnet 5.5 und Claude Haiku 5.5 nur in dem Konto funktionieren, das sie erzeugt hat, oder in einem damit verknüpften Konto. Siehe Thinking-Blöcke bleiben bei dem Konto, das sie erzeugt hat.

Redigierte Thinking-Blöcke

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

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

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

Limits und Feature-Kompatibilität

Sampling-Parameter

Auf Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5 und Claude Haiku 5.5 führen nicht standardmäßige Werte für temperature, top_p oder top_k bei jeder Anfrage zu einem 400-Fehler, unabhängig davon, ob Nachdenken verwendet wird. Auf diesen Modellen ist der Standardwert von top_p 0.99, sodass ein top_p von 1 einen 400-Fehler zurückgibt, ebenso wie eine Anfrage, die sowohl temperature als auch top_p enthält, selbst bei ihren Standardwerten. Siehe Sampling-Parameter entfernen. Auf älteren Modellen gilt die Einschränkung nur, solange das Nachdenken aktiviert ist: temperature und top_k sind mit Nachdenken inkompatibel, und top_p ist mit Werten zwischen 0,95 und 1 erlaubt.

Antwort-Prefill und erzwungene Tool-Nutzung

Claude 4.6 und spätere Modelle sowie Claude Mythos Preview lehnen einen vorausgefüllten letzten Assistant-Turn mit einem 400-Fehler ab, unabhängig davon, ob das Nachdenken aktiviert ist (siehe Prefill nicht unterstützt). Auf früheren Modellen kannst du die Assistant-Antwort nicht vorausfüllen, solange das Nachdenken aktiviert ist. Erzwungene Tool-Nutzung (tool_choice: {"type": "any"} oder {"type": "tool", ...}) ist mit manuellem erweitertem Nachdenken inkompatibel, funktioniert aber mit adaptivem Nachdenken. Die Ausnahmen sind Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 und Claude Mythos 5.1, die erzwungene Tool-Nutzung bei jeder Anfrage mit einem 400-Fehler ablehnen. Verwende auf diesen Modellen stattdessen tool_choice: {"type": "auto"} mit strikter Tool-Nutzung oder strukturierten Ausgaben. Wo erzwungene Tool-Nutzung akzeptiert wird, beginnt die Antwort mit dem Tool-Aufruf und hat keinen thinking-Block. Damit das Modell nachdenken kann, bevor es ein Tool aufruft, verwende tool_choice: {"type": "auto"} und gib im Prompt an, wann das Tool verwendet werden soll. Siehe Nachdenken mit Tool-Nutzung.

Output-Limits

Jedes Modell akzeptiert max_tokens bis zur hier aufgeführten Obergrenze. Auf der Message Batches API hebt der Beta-Header output-300k-2026-03-24 diese Obergrenze für die Modelle an, bei denen eine Batches-Obergrenze aufgeführt ist.

Siehe die Modellübersicht für Limits bei veralteten Modellen.

Lange Anfragen

Das SDK erfordert 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(), um das vollständige Message-Objekt zu erhalten, ohne es selbst aus einzelnen Events zusammenzusetzen. Siehe Streaming von Nachrichten. Rechne mit längeren Antwortzeiten, wenn das Nachdenken aktiv ist, da das Generieren von Thinking-Blöcken Verarbeitungszeit hinzufügt. Für Workloads, die das Nachdenken auf mehr als etwa 32k Token pro Anfrage treiben, 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