Denken

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

Denken hebt diese Einschränkung auf. Wenn Denken 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. Diese Überlegungen kommen in thinking-Content-Blöcken vor der Antwort an, und Claude stützt sich darauf, um die endgültige Antwort zu erzeugen. Deshalb verbessert Denken 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.

Denken hat einen Preis: Die Token, die Claude für das Nachdenken aufwendet, werden als Output-Token abgerechnet, selbst wenn der Denktext nicht an dich zurückgegeben wird, und sie zählen zusammen mit dem Antworttext zu max_tokens. Diese Seite behandelt, wie sich Denken über die gesamte API-Oberfläche verhält: wie du es aktivierst, seine Ausgabe liest und seine Wechselwirkungen mit Tools, Streaming, Caching und dem Kontextfenster verwaltest.



Wie Denken funktioniert

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

So sieht Denken in einer Antwort aus: Ein oder mehrere thinking-Content-Blöcke kommen vor den text-Blöcken an. Der Denkblock ist weiterhin generierter Inhalt, wie der darauf folgende text-Block, aber er ist von der kanonischen Antwort getrennt. Jeder Denkblock trägt außerdem ein signature-Feld, eine verschlüsselte Kopie der vollständigen Überlegungen, die du in Multi-Turn- und Tool-Nutzungs-Konversationen unverändert zurückgibst (siehe Denkverschlü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 Denkblock ist eine Zusammenfassung von Claudes Überlegungen. Das display-Feld in der Denkkonfiguration steuert, ob diese Zusammenfassung überhaupt zurückgegeben wird: "summarized" gibt sie zurück, während "omitted", der Standard bei den neuesten Modellen, Denkblö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 Steuerung der Denkanzeige für modellspezifische Standardwerte und Details.

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



Denken konfigurieren

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

Bei Claude Opus 5, Claude Sonnet 5, Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview ist Denken bereits aktiviert: keine Konfiguration nötig. Das Erste, was die meisten Entwickler bei diesen Modellen brauchen, ist, den Denktext zu sehen, da display dort standardmäßig "omitted" ist. 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 Denken deaktiviert, bis du thinking: {type: "adaptive"} in deiner Anfrage setzt. Die folgenden Beispiele tun das, setzen display: "summarized", damit der Denktext 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 Denken 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...

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



Denken deaktivieren

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

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 Denken ebenfalls standardmäßig aktiviert und akzeptiert thinking: {type: "disabled"} bei Effort high oder darunter. Bei xhigh- oder max-Effort kann Denken nicht deaktiviert 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 Denken kann Claude Opus 5 gelegentlich Tool-Aufrufe als Klartext ausgeben oder interne XML-Tags in seine sichtbare Ausgabe aufnehmen; siehe Ausführung mit deaktiviertem Denken für Prompting-Gegenmaßnahmen.

Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview lehnen thinking: {type: "disabled"} ab: Denken kann bei diesen Modellen nicht deaktiviert 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 Denkkonfiguration mit einem 400-Fehler zurückkommt, ordnet Troubleshooting für Denken jede Fehlermeldung ihrer Lösung zu.



Denkausgabe lesen



Steuerung der Denkanzeige

Das display-Feld in der Denkkonfiguration steuert, wie Denkinhalte 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": Denkblöcke enthalten zusammengefassten Denktext, eine lesbare Zusammenfassung von Claudes Überlegungen. Dies ist der Standard bei Claude Opus 4.6, Claude Sonnet 4.6 und früheren Modellen.
• "omitted": Denkblöcke werden mit einem leeren thinking-Feld zurückgegeben. Das signature-Feld trägt weiterhin das verschlüsselte vollständige Denken für Multi-Turn-Kontinuität (siehe Denkverschlü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 Denkinhalte nicht für Benutzer anzeigt. Der Hauptvorteil ist eine schnellere Zeit bis zum ersten Text-Token beim Streaming: Der Server überspringt das Streaming der Denk-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 Denken:

• Dir werden weiterhin die vollständigen Denk-Token berechnet. Das Auslassen reduziert die Latenz, nicht die Kosten.
• Wenn du Denkblöcke in Multi-Turn-Konversationen zurückgibst, gib sie unverändert zurück. Der Server entschlüsselt die signature, um das ursprüngliche Denken für die Prompt-Konstruktion zu rekonstruieren (siehe Denkblöcke bewahren). Jeder 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).
• Wenn thinking.type: "adaptive" verwendet wird und das Modell das Denken bei einer einfachen Anfrage überspringt, wird unabhängig von display kein Denkblock erzeugt.
• Beim Streaming mit display: "omitted" werden keine thinking_delta-Events ausgegeben; siehe Streaming von Denken für die Event-Sequenz.

Im Ruby SDK setzt du dieses Feld als display_: (mit nachgestelltem Unterstrich), um Rubys Kernel#display nicht zu überschatten; das Wire-Feld ist weiterhin display.



Zusammengefasstes Denken

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

Beachte Folgendes bei der Arbeit mit zusammengefasstem Denken:

• Dir werden die vollständigen Denk-Token berechnet, die von der ursprünglichen Anfrage generiert wurden, nicht die Zusammenfassungs-Token. Die abgerechnete Anzahl der Output-Token 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 Denkausgabe 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 Denkblöcke diese ausführliche Einleitung nicht.
• Die Zusammenfassung bewahrt die Kernideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz und ermöglicht eine streambare Benutzererfahrung.
• Die Zusammenfassung wird von einem anderen Modell verarbeitet als dem, das du in deinen Anfragen ansprichst. Das Denkmodell sieht die zusammengefasste Ausgabe nicht.
• Da Anthropic die Denkfunktion weiter verbessern möchte, kann sich das Zusammenfassungsverhalten ändern.



Streaming von Denken

Denken funktioniert mit Streaming. Denkblö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. Textblöcke werden danach wie gewohnt gestreamt.

Die folgenden Beispiele streamen eine Antwort mit adaptivem Denken und geben Denk- und Text-Deltas aus, sobald 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)

Wenn display: "omitted" gesetzt ist, öffnet sich der Denkblock, 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-Mechanismen siehe Streaming von Messages.



Denken 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 Denkverhalten macht, findest du in der Tabelle des Denkverhaltens pro Stufe auf der Seite Denken steuern; die Seite Effort 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 Feinabstimmung.

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

• Geringere Kosten oder Latenz bei einem Workload mit aktiviertem Denken: Senke zuerst effort. Es skaliert die gesamte Antwort herunter, einschließlich des Denkens.
• Claude denkt zu selten oder zu oberflächlich: Erhöhe effort oder siehe Steuern, wie oft Claude denkt auf der Steuerungsseite.
• Du brauchst Denken vollständig deaktiviert: Verwende thinking: {type: "disabled"} bei Modellen, die es erlauben (siehe die modellspezifische Konfigurationstabelle).
• Du brauchst eine harte Obergrenze für die Ausgaben: Verwende max_tokens. Effort ist eine weiche Vorgabe; max_tokens ist ein striktes Limit.



Denken mit Tool-Nutzung

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

1. Einschränkung bei der Tool-Auswahl (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, da diese Optionen Tool-Nutzung erzwingen, was mit manuellem erweitertem Denken inkompatibel ist. Adaptives Denken, einschließlich bei Modellen, bei denen Denken standardmäßig aktiviert ist, unterstützt erzwungene Tool-Nutzung.
2. Denkblöcke bewahren: Wenn du Tool-Ergebnisse zurückgibst, musst du die Denkblöcke aus der Assistant-Nachricht vollständig und unverändert an die API zurückgeben. Siehe Denkblö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 enthalten kann. Diese gesamte Sequenz 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 Denkmodus: Du kannst Denken 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 Denken mit einem Denkblock beginnt. Der adaptive Modus lockert dies: Kein Assistant-Turn muss mit einem beginnen.

Konflikte mitten im Turn werden elegant abgefangen. Wenn du Denken 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 Denken für diese Anfrage stillschweigend. Um die Modellqualität zu erhalten, kann die API Denkblöcke entfernen, die eine ungültige Turn-Struktur erzeugen würden, oder Denken deaktivieren, wenn der Konversationsverlauf mit aktiviertem Denken inkompatibel ist. Um zu bestätigen, ob Denken aktiv war, prüfe auf das Vorhandensein von thinking-Blöcken in der Antwort.

Schalte zwischen Turns um, nicht innerhalb. Plane deine Denkstrategie zu Beginn jedes Turns. Schließe den Assistant-Turn ab und ändere dann die Denkkonfiguration 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)

Beachte, dass das Umschalten der Denkmodi auch das Prompt-Caching ungültig macht; siehe Denken und Prompt-Caching.



Denkblö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, setzt Claude den Aufbau derselben Antwort fort, 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 Denkblö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. Kontexterhaltung: Tool-Ergebnisse erscheinen in der API-Struktur als User-Nachrichten, aber sie sind Teil eines kontinuierlichen Denkflusses. Das Bewahren von Denkblöcken erhält diesen Fluss über API-Aufrufe hinweg.

Kurz gesagt:

• Erforderlich: Innerhalb eines Tool-Nutzungs-Turns gib Denkblöcke zurück.
• Empfohlen: Über Turns hinweg gib alles zurück.
• Erlaubt: Außerhalb der Tool-Nutzung kannst du das Denken früherer Turns weglassen.

Du musst altes Denken nicht selbst entfernen. Gib alle Denkblöcke in Multi-Turn-Konversationen zurück, und die API filtert sie automatisch, behält die Blöcke, die zur Bewahrung der Überlegungen des Modells nötig sind, und berechnet Input-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 Bewahrung von Denkblöcken 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 mit dem übereinstimmen, was das Modell in der ursprünglichen Anfrage generiert hat: Du kannst sie nicht umordnen, 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 Denken in Tool- und Multi-Turn-Workflows. Sie definiert ein Tool, empfängt eine Antwort mit Denken plus Tool-Nutzung und gibt den Assistant-Turn mit dem Tool-Ergebnis zurück.



Verschachteltes Denken

Verschachteltes Denken (interleaved thinking) lässt Claude zwischen Tool-Aufrufen denken und über jedes Tool-Ergebnis nachdenken, bevor es darauf reagiert. Mit verschachteltem Denken kann Claude:

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

Mit adaptivem Denken ist verschachteltes Denken bei jedem Modell, das adaptives Denken unterstützt, automatisch; 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 erscheinen Überlegungen zwischen Tool-Aufrufen immer in Denkblöcken. Claude Haiku 4.5 unterstützt kein verschachteltes Denken. Bei Modellen mit manuellem erweitertem Denken erfordert die Verschachtelung einen Beta-Header und ändert, wie das Denkbudget gezählt wird; Verschachteltes Denken im manuellen Modus behandelt die modellspezifischen Regeln und das plattformspezifische Header-Verhalten.

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

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



Bewahrung von Denkblöcken nach Modell

Ob Denkblö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 Denkblöcke zurückgibst, entfernt die API sie automatisch; du musst sie nicht selbst entfernen.

Die Bewahrung bringt zwei Vorteile:

• Cache-Optimierung: Bewahrte Denkblö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 Denkblöcken hat keinen negativen Effekt auf die Modellleistung.

Der Kompromiss ist die Kontextnutzung: Lange Konversationen verbrauchen bei Modellen, die alles behalten, mehr Kontextplatz, da beibehaltene Denkblöcke wie jeder andere Konversationsverlauf als Input zählen (siehe Denken 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 Denkblöcke zurückgeben, wie in Denkblöcke bewahren beschrieben. Um den Standard in eine der beiden Richtungen zu überschreiben, verwende Denkblock-Bereinigung.

Modellwechsel mitten in der Konversation. 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. Denkblöcke sind an das Modell gebunden, das sie erzeugt hat. Andere Modelle ignorieren sie stillschweigend, statt die Anfrage abzulehnen, aber ignorierte Blöcke fügen trotzdem Input-Token hinzu.



Denken und Prompt-Caching

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

Konfigurationsänderungen machen das Caching ungültig. Die Denkkonfiguration und die aufgelöste effort-Stufe werden in den Prompt selbst gerendert, daher startet jede Änderung einen neuen Cache-Präfix. 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 Denk- oder Effort-Änderung so, als würde der Cache neu gestartet. Aufeinanderfolgende Anfragen, die dieselbe Konfiguration beibehalten, bewahren den Cache, und das explizite Setzen eines Parameters auf seinen Standardwert ist gleichbedeutend mit dem Weglassen. Eine ausgearbeitete Demonstration mit Usage-Ausgabe findest du auf der Seite Denken steuern.

Denkblö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 Denkblöcke, gecacht werden, und diese gecachten Denkblö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 verschachteltes Denken gleich. Der Kompromiss: Denkblöcke, die du in Antworten nie wieder 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 Modellen, die alles behalten, bleiben die Denkblöcke früherer Turns gecacht und im Kontext. Bei Modellen, die nur den letzten Turn behalten, werden alle früheren Denkblöcke aus dem Kontext entfernt, sobald du eine User-Nachricht sendest, die kein Tool-Ergebnis ist. 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 Denkblö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 Modellen, die alles behalten, behält dieselbe Anfrage thinking_block_1 und thinking_block_2 im Kontext und im Cache.

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



Denken und das Kontextfenster

max_tokens, das alles Denken einschließt, das Claude im aktuellen Turn generiert, wird als striktes Limit durchgesetzt. Bei Claude-4.5-Modellen und neueren akzeptiert die API die Anfrage, wenn Input-Token plus max_tokens die Größe des Kontextfensters überschreiten; wenn die Generierung dann das Kontextfenster-Limit erreicht, stoppt sie mit stop_reason: "model_context_window_exceeded", statt einen Fehler zurückzugeben. Bei früheren Modellen gibt die API stattdessen einen Validierungsfehler zurück. Siehe Umgang mit Stop-Gründen.

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

• Denken im aktuellen Turn zählt immer zu max_tokens, wird als Output-Token abgerechnet und belegt Kontextfensterplatz für den Turn, der es generiert hat.
• Denken aus früheren Turns hängt vom Bewahrungsstandard ab. Bei Modellen, die alle früheren Turns behalten, bleiben frühere Denkblö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 Denkblöcke automatisch, wenn du sie zurückgibst, sodass sie weder Fensterplatz noch Input-Token verbrauchen.

In der Praxis:

• Bei Modellen, die alles behalten, budgetiere dein Kontextfenster so, als wäre Denken gewöhnlicher Konversationsverlauf, denn das ist es. Lange agentische Sitzungen akkumulieren Denken im Kontext; verwende Denkblock-Bereinigung, wenn du Platz zurückgewinnen musst.
• Bei Modellen, die nur den letzten Turn behalten, ist Denken nur ein Kostenfaktor pro Turn: Das Denken jedes Turns zählt zu den 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 (Entfernung). Das erste zeigt eine Multi-Turn-Konversation: Der Denkblock jedes Turns wird in der Ausgabe generiert, aber nicht in den Input späterer Turns übernommen.

Das zweite zeigt dasselbe Regime mit Tool-Nutzung: Denken 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, insbesondere für Multi-Turn-Konversationen, die Denken enthalten.



Denkverschlüsselung

Der vollständige Denkinhalt wird verschlüsselt und im signature-Feld jedes Denkblocks zurückgegeben. Die API verwendet die Signatur, um zu verifizieren, dass Denkblöcke von Claude generiert wurden, wenn du sie zurückgibst.

Beachte Folgendes bei der Arbeit mit Signaturen:

• Es ist nur dann zwingend erforderlich, Denkblöcke zurückzusenden, wenn du Tools mit Denken verwendest. Andernfalls kannst du Denkblö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 Bewahrung von Denkblöcken nach Modell); verwende Context Editing, um dies zu konfigurieren.
• Wenn du Denkblö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 signature-Feld ist opak: Interpretiere oder parse es nicht.
• signature-Werte sind plattformübergreifend kompatibel (Claude APIs, Amazon Bedrock und Google Cloud). Werte, die auf einer Plattform generiert wurden, funktionieren auf einer anderen.



Redigierte Denkblöcke

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

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

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



Denkausgabe 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, keine redacted_thinking, und die display-Einstellung funktioniert genauso wie bei anderen Modellen (zusammengefasster Text oder ein leeres thinking-Feld bei Auslassung, dem Standard hier). Für die Antwortstruktur von Denkblöcken siehe die Messages-API-Referenz.

Wenn du eine Konversation mit demselben Modell fortsetzt, gib jeden Denkblock 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.

Was mit Denkblöcken passiert, wenn du mitten in der Konversation das Modell wechselst, findest du unter Bewahrung von Denkblöcken nach Modell.

Zwei Ausnahmen, behandelt in Fallback-Credit:

• Fallback-Credit-Wiederholungen müssen den abgelehnten Anfragekörper unverändert zurückgeben.
• fallback-Blöcke aus einem Fallback mitten in der Ausgabe bleiben dort, wo sie erschienen sind.

Um Einblick in die Überlegungen des Modells zu erhalten, lies die auf dieser Seite beschriebenen thinking-Blöcke, statt im Antworttext nach Begründungen zu fragen. Bei Claude Fable 5 kann eine Anfrage, die versucht, die internen Überlegungen des Modells als Teil des Antworttexts zu entlocken, mit stop_details.category: "reasoning_extraction" abgelehnt werden. Siehe Ablehnungskategorien 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 führen von den Standardwerten abweichende temperature-, top_p- oder top_k-Werte bei jeder Anfrage zu einem 400-Fehler, unabhängig davon, ob Thinking verwendet wird. Bei älteren Modellen gilt die Einschränkung nur, während Thinking aktiviert ist: temperature und top_k sind mit Thinking inkompatibel, und top_p ist bei Werten zwischen 0,95 und 1 erlaubt.

Response-Prefill und erzwungene Tool-Nutzung. Du kannst die Assistant-Antwort nicht vorausfüllen, während Thinking aktiviert ist. Erzwungene Tool-Nutzung (tool_choice: {"type": "any"} oder {"type": "tool", ...}) ist mit manuellem erweitertem Denken inkompatibel, funktioniert aber mit adaptivem Thinking; siehe Thinking 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. Bei der Message Batches API erhöht der Beta-Header output-300k-2026-03-24 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 Thinking aktiv ist, da das Generieren von Thinking-Blöcken zusätzliche Verarbeitungszeit erfordert. Für Workloads, bei denen Thinking über etwa 32k Token pro Anfrage hinausgeht, 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