--- title: Nachdenken url: https://platform.claude.com/docs/de/build-with-claude/thinking description: "Verstehe, wie Claudes Nachdenken funktioniert: schalte es ein, lies die Denkausgabe, steuere die Denktiefe mit Effort und nutze Nachdenken zusammen mit Tools, Caching und Streaming." --- Um zu erfahren, wie „zero data retention“ (Null-Datenspeicherung), oder ZDR, auf diese Funktion angewendet wird, siehe [API und Datenspeicherung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention). 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 ![Diagramm: Claude entscheidet, ob es vorab nachdenkt („thinking up front"), kann zwischen Tool-Aufrufen („tool calls") nachdenken und gibt Thinking-Blöcke („thinking blocks") vor dem Text zurück](https://platform.claude.com/docs/de/images/how-thinking-works.svg) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-encryption)): ```json { "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](https://platform.claude.com/docs/de/build-with-claude/thinking#summarized-thinking). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display) für modellspezifische Standardwerte und Details. Wenn Claude Tools verwendet, kann Nachdenken auch zwischen Tool-Aufrufen erscheinen. Siehe [Nachdenken mit Tool-Nutzung](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use). Das vollständige Antwortformat findest du in der [Messages-API-Referenz](https://platform.claude.com/docs/de/api/messages/create). ## 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](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting) listet jeden Fehler und seine Lösung auf. | Modell | Kein `thinking`-Feld | `"adaptive"` | `"enabled"` mit `budget_tokens` | `"between_tools"` | `"disabled"` | | --------------------- | -------------------- | -------------------- | ------------------------------------ | ----------------------------------------------------- | ----------------------------------------------- | | Claude Opus 5.5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | 400-Fehler | | Claude Sonnet 5.5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | Vorab-Nachdenken aus bei Effort `high` oder niedriger | 400-Fehler | | Claude Haiku 5.5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | Nachdenken aus bei Effort `high` oder niedriger | | Claude Fable 5.1 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | 400-Fehler | | Claude Mythos 5.1 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | 400-Fehler | | Claude Fable 5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | 400-Fehler | | Claude Mythos 5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | 400-Fehler | | Claude Opus 5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | Nachdenken aus bei Effort `high` oder niedriger | | Claude Sonnet 5 | Adaptives Nachdenken | Adaptives Nachdenken | 400-Fehler | 400-Fehler | Nachdenken aus | | Claude Opus 4.8 | Nachdenken aus | Adaptives Nachdenken | 400-Fehler | 400-Fehler | Nachdenken aus | | Claude Opus 4.7 | Nachdenken aus | Adaptives Nachdenken | 400-Fehler | 400-Fehler | Nachdenken aus | | Claude Mythos Preview | Adaptives Nachdenken | Adaptives Nachdenken | Erweitertes Nachdenken | 400-Fehler | 400-Fehler | | Claude Opus 4.6 | Nachdenken aus | Adaptives Nachdenken | Erweitertes Nachdenken (abgekündigt) | 400-Fehler | Nachdenken aus | | Claude Sonnet 4.6 | Nachdenken aus | Adaptives Nachdenken | Erweitertes Nachdenken (abgekündigt) | 400-Fehler | Nachdenken aus | | Claude Opus 4.5 | Nachdenken aus | 400-Fehler | Erweitertes Nachdenken | 400-Fehler | Nachdenken aus | | Claude Sonnet 4.5 | Nachdenken aus | 400-Fehler | Erweitertes Nachdenken | 400-Fehler | Nachdenken aus | | Claude Haiku 4.5 | Nachdenken aus | 400-Fehler | Erweitertes Nachdenken | 400-Fehler | Nachdenken aus | 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](https://platform.claude.com/docs/de/models/overview) schaltet es dort ein. Die folgenden Beispiele setzen `display: "summarized"`, damit der Thinking-Text sichtbar ist, und verwenden ein großzügiges `max_tokens`: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "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?" } ] }' ``` ```bash CLI ant messages create \ --model claude-opus-5-5 \ --max-tokens 16000 \ --thinking '{type: adaptive, display: summarized}' \ --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \ --transform content \ --format yaml ``` ```python Python 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}") ``` ```typescript TypeScript const client = new Anthropic(); const response = await 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 (const block of response.content) { switch (block.type) { case "thinking": console.log(`\nThinking: ${block.thinking}`); break; case "text": console.log(`\nResponse: ${block.text}`); break; } } ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized }, Messages = [ new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" } ] }; var message = await client.Messages.Create(parameters); foreach (var block in message.Content) { if (block.TryPickThinking(out ThinkingBlock? thinking)) { Console.WriteLine($"\nThinking: {thinking.Thinking}"); } else if (block.TryPickText(out TextBlock? text)) { Console.WriteLine($"\nResponse: {text.Text}"); } } ``` ```go Go client := anthropic.NewClient() response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{ Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized, }, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")), }, }) if err != nil { log.Fatal(err) } for _, block := range response.Content { switch v := block.AsAny().(type) { case anthropic.ThinkingBlock: fmt.Printf("\nThinking: %s", v.Thinking) case anthropic.TextBlock: fmt.Printf("\nResponse: %s", v.Text) } } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigAdaptive; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder() .display(ThinkingConfigAdaptive.Display.SUMMARIZED) .build()) .addUserMessage("What is the greatest common divisor of 1071 and 462?") .build(); Message response = client.messages().create(params); response.content().forEach(block -> { block.thinking().ifPresent(thinkingBlock -> IO.println("\nThinking: " + thinkingBlock.thinking()) ); block.text().ifPresent(textBlock -> IO.println("\nResponse: " + textBlock.text()) ); }); } ``` ```php PHP use Anthropic\Messages\TextBlock; use Anthropic\Messages\ThinkingBlock; $client = new Client(); $message = $client->messages->create( maxTokens: 16000, messages: [ [ 'role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?' ] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive', 'display' => 'summarized'], ); foreach ($message->content as $block) { switch (true) { case $block instanceof ThinkingBlock: echo "\nThinking: " . $block->thinking; break; case $block instanceof TextBlock: echo "\nResponse: " . $block->text; break; } } ``` ```ruby Ruby client = Anthropic::Client.new message = client.messages.create( model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive", # Ein einfacher Hash wie dieser nimmt display: an. Die typisierte Klasse ThinkingConfigAdaptive # schreibt es als display_ (mit Unterstrich am Ende), um Rubys Kernel#display nicht zu überdecken. # Die Anfrage sendet trotzdem display. display: "summarized" }, messages: [ { role: "user", content: "What is the greatest common divisor of 1071 and 462?" } ] ) message.content.each do |block| case block when Anthropic::Models::ThinkingBlock puts "\nThinking: #{block.thinking}" when Anthropic::Models::TextBlock puts "\nResponse: #{block.text}" end end ``` Wenn du das Beispiel ausführst, wird zuerst das zusammengefasste Nachdenken und dann die Antwort ausgegeben: ```text Output wrap 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](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#cost-control) auf der Steuerungsseite und [Nachdenken und das Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-the-context-window). ### Nachdenken ausschalten Auf Claude Sonnet 5, wo Nachdenken standardmäßig aktiv ist, kannst du es ausschalten: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-sonnet-5", "max_tokens": 4096, "thinking": {"type": "disabled"}, "messages": [ { "role": "user", "content": "Summarize this article in one sentence." } ] }' ``` ```bash CLI ant messages create \ --model claude-sonnet-5 \ --max-tokens 4096 \ --thinking '{type: disabled}' \ --message '{role: user, content: "Summarize this article in one sentence."}' ``` ```python Python 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."}], ) ``` ```typescript TypeScript const client = new Anthropic(); const response = await client.messages.create({ model: "claude-sonnet-5", max_tokens: 4096, thinking: { type: "disabled" }, messages: [{ role: "user", content: "Summarize this article in one sentence." }] }); ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeSonnet5, MaxTokens = 4096, Thinking = new ThinkingConfigDisabled(), Messages = [ new() { Role = Role.User, Content = "Summarize this article in one sentence." } ] }; var message = await client.Messages.Create(parameters); ``` ```go Go client := anthropic.NewClient() response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeSonnet5, MaxTokens: 4096, Thinking: anthropic.ThinkingConfigParamUnion{ OfDisabled: &anthropic.ThinkingConfigDisabledParam{}, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize this article in one sentence.")), }, }) if err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigDisabled; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_SONNET_5) .maxTokens(4096L) .thinking(ThinkingConfigDisabled.builder().build()) .addUserMessage("Summarize this article in one sentence.") .build(); Message response = client.messages().create(params); } ``` ```php PHP $client = new Client(); $message = $client->messages->create( maxTokens: 4096, messages: [ [ 'role' => 'user', 'content' => 'Summarize this article in one sentence.' ] ], model: 'claude-sonnet-5', thinking: ['type' => 'disabled'], ); ``` ```ruby Ruby client = Anthropic::Client.new message = 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](https://platform.claude.com/docs/de/build-with-claude/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](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) 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](https://platform.claude.com/docs/de/build-with-claude/effort) `high` oder niedriger akzeptiert. Das Modell gibt weiterhin seine [Fortschrittsmeldungen zwischen Tool-Aufrufen](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) zurück. Ohne Tools enthält die Antwort nur Text, wie bei `disabled` auf Claude Sonnet 5. Siehe [Ausführung ohne vorgelagertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking) für Hinweise zum Prompting. Claude Haiku 5.5 hat Nachdenken ebenfalls standardmäßig aktiviert und akzeptiert `thinking: {type: "disabled"}` bei [Effort](https://platform.claude.com/docs/de/build-with-claude/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](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta), das von der aktuell geltenden Stufe abweicht, gibt bei ausgeschaltetem Nachdenken ebenfalls einen 400-Fehler zurück. Siehe [Effort zur Steuerung des Nachdenkens verwenden](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking) und [Adaptives Nachdenken mit JSON-Ausgabe und deinen eigenen Tools verwenden](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#json-output-with-your-own-tools). 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](https://platform.claude.com/docs/de/models/overview#using-the-models-api) beschreibt das Feld. Wenn dein Modell nur erweitertes Nachdenken unterstützt (siehe die [modellspezifische Konfigurationstabelle](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#supported-models)), konfiguriere es stattdessen mit `type: "enabled"` und einem `budget_tokens`-Wert. Die Seite [Erweitertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking) behandelt diese Konfiguration. Und wenn eine Thinking-Konfiguration einen 400-Fehler zurückgibt, ordnet [Fehlerbehebung beim Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#summarized-thinking) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-encryption)). 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](https://anthropic.com/glasswing) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates), 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: ```json Output { "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](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks)). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates)). * 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](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) `thinking_delta`-Events, die Text enthalten. Siehe [Nachdenken streamen](https://platform.claude.com/docs/de/build-with-claude/thinking#streaming-thinking) für die Event-Abfolge. Das `signature`-Feld ist identisch, unabhängig davon, welchen `display`-Wert du setzt. Das Wechseln von `display`-Werten zwischen Turns in einer Konversation wird unterstützt. ### 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](https://anthropic.com/glasswing) 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. In seltenen Fällen, in denen du Zugriff auf die vollständige Thinking-Ausgabe benötigst, [kontaktiere den Anthropic-Vertrieb](mailto:sales@anthropic.com). 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](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#refusal-response) für die Feldreferenz und [Reasoning in Thinking-Blöcken belassen](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks) dafür, worum du stattdessen bitten solltest. ### Nachdenken streamen Nachdenken funktioniert mit [Streaming](https://platform.claude.com/docs/de/build-with-claude/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. ![Diagramm der Streaming-Event-Abfolge mit Nachdenken: Der Thinking-Block („thinking block") öffnet sich, Thinking-Deltas („thinking deltas") enthalten nur dann Text, wenn die display-Einstellung Text zurückgibt (summarized, oder updates für Fortschrittsmeldungs-Blöcke), ein einzelnes Signatur-Delta („signature delta") schließt den Block, dann werden Text-Deltas („text deltas") gestreamt](https://platform.claude.com/docs/de/images/how-thinking-streams.svg) Die folgenden Beispiele streamen eine Antwort mit adaptivem Nachdenken und geben Thinking- und Text-Deltas aus, sobald sie eintreffen: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 16000, "stream": true, "thinking": { "type": "adaptive", "display": "summarized" }, "messages": [ { "role": "user", "content": "What is the greatest common divisor of 1071 and 462?" } ] }' ``` ```bash CLI ant messages create \ --model claude-opus-5-5 \ --max-tokens 16000 \ --thinking '{type: adaptive, display: summarized}' \ --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \ --stream \ --format jsonl ``` ```python Python 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) ``` ```typescript TypeScript const client = new Anthropic(); const stream = 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?" }] }); for await (const event of stream) { switch (event.type) { case "content_block_start": console.log(`\nStarting ${event.content_block.type} block...`); break; case "content_block_delta": switch (event.delta.type) { case "thinking_delta": process.stdout.write(event.delta.thinking); break; case "text_delta": process.stdout.write(event.delta.text); break; } break; } } ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized }, Messages = [new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" }] }; await foreach (var rawEvent in client.Messages.CreateStreaming(parameters)) { if (rawEvent.TryPickContentBlockStart(out var start)) { Console.WriteLine($"\nStarting {start.ContentBlock.Type} block..."); } else if (rawEvent.TryPickContentBlockDelta(out var delta)) { if (delta.Delta.TryPickThinking(out var thinkingDelta)) { Console.Write(thinkingDelta.Thinking); } else if (delta.Delta.TryPickText(out var textDelta)) { Console.Write(textDelta.Text); } } } ``` ```go Go client := anthropic.NewClient() stream := client.Messages.NewStreaming(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{ Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized, }, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")), }, }) for stream.Next() { event := stream.Current() switch eventVariant := event.AsAny().(type) { case anthropic.ContentBlockStartEvent: fmt.Printf("\nStarting %s block...\n", eventVariant.ContentBlock.Type) case anthropic.ContentBlockDeltaEvent: switch deltaVariant := eventVariant.Delta.AsAny().(type) { case anthropic.ThinkingDelta: fmt.Print(deltaVariant.Thinking) case anthropic.TextDelta: fmt.Print(deltaVariant.Text) } } } if err := stream.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigAdaptive; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder() .display(ThinkingConfigAdaptive.Display.SUMMARIZED) .build()) .addUserMessage("What is the greatest common divisor of 1071 and 462?") .build(); try (var streamResponse = client.messages().createStreaming(params)) { streamResponse.stream().forEach(event -> { switch (event.type().value()) { case CONTENT_BLOCK_START -> { var startEvent = event.asContentBlockStart(); var block = startEvent.contentBlock(); switch (block.type().value()) { case THINKING -> IO.println("\nStarting thinking block..."); case TEXT -> IO.println("\nStarting text block..."); } } case CONTENT_BLOCK_DELTA -> { var deltaEvent = event.asContentBlockDelta(); deltaEvent.delta().thinking().ifPresent(td -> IO.print(td.thinking()) ); deltaEvent.delta().text().ifPresent(td -> IO.print(td.text()) ); } } }); } } ``` ```php PHP use Anthropic\Messages\RawContentBlockDeltaEvent; use Anthropic\Messages\RawContentBlockStartEvent; use Anthropic\Messages\TextDelta; use Anthropic\Messages\ThinkingDelta; $client = new Client(); $stream = $client->messages->createStream( maxTokens: 16000, messages: [ ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive', 'display' => 'summarized'], ); foreach ($stream as $event) { switch (true) { case $event instanceof RawContentBlockStartEvent: echo "\nStarting {$event->contentBlock->type} block...\n"; break; case $event instanceof RawContentBlockDeltaEvent: switch (true) { case $event->delta instanceof ThinkingDelta: echo $event->delta->thinking; break; case $event->delta instanceof TextDelta: echo $event->delta->text; break; } break; } } ``` ```ruby Ruby client = Anthropic::Client.new stream = client.messages.stream( model: "claude-opus-5-5", max_tokens: 16000, # Ein einfacher Hash wie dieser nimmt display: an. Die typisierte Klasse ThinkingConfigAdaptive # schreibt es display_ (mit Unterstrich am Ende), um Rubys Kernel#display nicht zu überdecken. # Die Anfrage sendet trotzdem display. thinking: { type: "adaptive", display: "summarized" }, messages: [ { role: "user", content: "What is the greatest common divisor of 1071 and 462?" } ] ) stream.each do |event| case event when Anthropic::Streaming::ThinkingEvent print event.thinking when Anthropic::Streaming::TextEvent print event.text end end ``` 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()` (typescript: `stream.finalMessage()`; ruby: `stream.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`), anstatt Deltas selbst zu verketten. ```sse Output 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: ```sse Output 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](https://platform.claude.com/docs/de/build-with-claude/thinking#progress-updates) 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: ```sse Output 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. Wenn du Streaming mit aktiviertem Nachdenken verwendest, bemerkst du möglicherweise, dass Text manchmal in größeren Blöcken eintrifft, abwechselnd mit kleinerer, Token-für-Token-Lieferung. Dies ist erwartetes Verhalten, insbesondere bei Thinking-Inhalten. Das Streaming-System verarbeitet Inhalte in Batches, was Streaming-Events verzögern und zu diesem „stückchenweisen" Liefermuster gruppieren kann. Allgemeine Streaming-Mechanismen findest du unter [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming). ## Nachdenken und Effort Der Parameter `thinking` steuert, ob Claude vor dem Antworten in [Thinking-Blöcken](https://platform.claude.com/docs/de/build-with-claude/thinking) 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](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#effort-levels) auf der Seite [Nachdenken steuern](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost). Die Seite [Effort](https://platform.claude.com/docs/de/build-with-claude/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](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#budget-rules-and-tuning). 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](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior) auf der Steuerungsseite. * **Du brauchst Nachdenken vollständig ausgeschaltet:** Verwende `thinking: {type: "disabled"}` auf Modellen, die dies erlauben (siehe die [modellspezifische Konfigurationstabelle](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#supported-models)). 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview)) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#limits-and-feature-compatibility)). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks). **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: ```text wrap 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: ```text wrap 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model). Um den Standard zu überschreiben, verwende die [Context-Editing-Strategie `clear_thinking_20251015`](https://platform.claude.com/docs/de/build-with-claude/context-editing#thinking-block-clearing). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#redacted-thinking-blocks) ein. Veränderte Thinking-Blöcke werden mit einem 400-Fehler abgelehnt. Siehe [Ein 400-Fehler besagt, dass Thinking-Blöcke nicht verändert werden dürfen](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#error-thinking-blocks-modified) für die genaue Meldung, die häufigen Ursachen und die Lösung. Die eine Ausnahme: Text, der in das leere `thinking`-Feld eines [ausgelassenen](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display) Blocks gesetzt wird, wird ignoriert statt abgelehnt. 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](https://platform.claude.com/docs/de/build-with-claude/thinking-tool-workflows#two-turn-tool-use-round-trip). 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 Aufeinanderfolgende Tool-Aufrufe erfordern kein verschachteltes Nachdenken. Claude kann Tool-Aufrufe mit oder ohne verschachteltes Nachdenken verketten. Die Verschachtelung ändert, wo Thinking-Blöcke zwischen Tool-Aufrufen erscheinen, nicht, ob Tool-Aufrufe verkettet werden können. 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](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#interleaved-thinking) 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview). 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](https://platform.claude.com/docs/de/build-with-claude/thinking-tool-workflows#how-interleaved-thinking-changes-the-flow). ### 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](https://platform.claude.com/docs/de/build-with-claude/thinking#interleaved-thinking): 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`](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display) ab: | `display` | Reasoning-Blöcke | Fortschrittsmeldungs-Blöcke | | ---------------------------------------------- | ---------------------- | -------------------------------------------------------------------- | | `"omitted"` (der Standard auf diesen Modellen) | Leeres `thinking`-Feld | Leeres `thinking`-Feld | | `"updates"` (Beta) | Leeres `thinking`-Feld | Zusammenfassungstext | | `"summarized"` | Zusammenfassungstext | Zusammenfassungstext, nicht von einem Reasoning-Block unterscheidbar | 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](https://platform.claude.com/docs/de/build-with-claude/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](https://platform.claude.com/docs/de/api/beta-headers#beta-features-on-other-platforms)). Ohne ihn wird der Wert mit demselben 400-`invalid_request_error` abgelehnt wie ein unbekannter `display`-Wert. ```json { "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. ```json Output { "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](https://platform.claude.com/docs/de/build-with-claude/thinking#streaming-thinking) mit einer Pause von mehreren Sekunden, bevor sich ein Fortschrittsmeldungs-Block öffnet. Siehe den `"updates"`-Trace unter [Nachdenken streamen](https://platform.claude.com/docs/de/build-with-claude/thinking#streaming-thinking). * Diese Modelle schreiben bei höherem [Effort](https://platform.claude.com/docs/de/build-with-claude/effort) und in langen Tool-Ketten weniger Fortschrittsmeldungen. Wenn deine Oberfläche davon abhängt, siehe [Nutzerseitige Fortschritts-Updates anfordern](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates) oder, für Claude Opus 5.5, [Fortschrittsmeldungen für Benutzer](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates). Für Claude Sonnet 5.5 siehe [Fortschrittsupdates für Nutzer](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates). ### 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-the-context-window)). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks) beschrieben. Um den Standard in eine der beiden Richtungen zu überschreiben, verwende das [Löschen von Thinking-Blöcken](https://platform.claude.com/docs/de/build-with-claude/context-editing#thinking-block-clearing). **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](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback). 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#switching-models)). 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](https://platform.claude.com/docs/de/build-with-claude/fallback-credit) einlöst, da dies einen unveränderten Body erfordert. ## Erhaltenes Nachdenken [Erhaltenes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking) 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#switching-models). * **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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#prefix-check). 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#account-bound-thinking), 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#what-counts-as-an-edit) und [wie du prüfst, ob dein Code eine vornimmt](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted). * [Das API-Feature, das jede gängige Bearbeitung ersetzt](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#replace-prefix-edits): 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#custom-compaction-on-the-client): welche Muster das Nachdenken gültig halten und welche nicht. * [Der Beta-Header `thinking-binding-controls-2026-08-01`](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#preserved-thinking-controls). 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](https://platform.claude.com/docs/de/build-with-claude/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`](https://platform.claude.com/docs/de/build-with-claude/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](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) 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](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-thinking) 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](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#prompt-caching). **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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model) 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: ```text wrap 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: ```text wrap 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use)). [Verschachteltes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking#interleaved-thinking) verstärkt die Effekte der Cache-Invalidierung, da Thinking-Blöcke zwischen mehreren Tool-Aufrufen auftreten können. Aufgaben mit viel Nachdenken dauern oft länger als die standardmäßige Cache-Lebensdauer von 5 Minuten. Erwäge die [1-Stunden-Cache-Dauer](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#1-hour-cache-duration), um Cache-Treffer über längere Thinking-Sitzungen und mehrstufige Workflows hinweg zu erhalten. ## 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](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model) ab. Auf [Modellen, die alle vorherigen Turns behalten](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model), 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](https://platform.claude.com/docs/de/build-with-claude/context-editing#thinking-block-clearing), 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. ![Diagramm des Nachdenkens auf einem Modell, das vorherige Thinking-Blöcke entfernt: Der Thinking-Block jedes Turns wird in der Ausgabe generiert und nicht in die Eingabe späterer Turns übernommen](https://platform.claude.com/docs/de/images/context-window-thinking.svg) 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. ![Diagramm des Nachdenkens mit Tool-Nutzung auf einem Modell, das vorherige Thinking-Blöcke entfernt: Das Nachdenken wird mit seinem Tool-Ergebnis behalten und dann beim nächsten Benutzer-Turn verworfen](https://platform.claude.com/docs/de/images/context-window-thinking-tools.svg) Verwende die [Token-Counting-API](https://platform.claude.com/docs/de/build-with-claude/token-counting), 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model)). Verwende [Kontextbearbeitung](https://platform.claude.com/docs/de/build-with-claude/context-editing), 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](https://platform.claude.com/docs/de/build-with-claude/thinking#streaming-thinking) 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](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) und [Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai)). 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](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#account-bound-thinking). ## 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: ```json { "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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use) fortsetzt. Wenn dein Code Content-Blöcke nach Typ filtert (zum Beispiel `block.type == "thinking"`), wenn er Antworten mit Tool-Nutzung hin- und zurückreicht, schließe auch `redacted_thinking`-Blöcke ein. Das Filtern allein auf `block.type == "thinking"` verwirft `redacted_thinking`-Blöcke stillschweigend und bricht das in [Thinking-Blöcke bewahren](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks) beschriebene Multi-Turn-Protokoll. `redacted_thinking`-Blöcke sind ein eigener Content-Block-Typ, der zurückgegeben wird, wenn Thinking aus Sicherheitsgründen redigiert wird. Dies ist getrennt von der Option [`display: "omitted"`](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display), die reguläre `thinking`-Blöcke mit einem leeren `thinking`-Feld zurückgibt. ## 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](https://platform.claude.com/docs/de/models/haiku-5-5/migration-guide#remove-sampling-parameters). 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](https://platform.claude.com/docs/de/api/errors#prefill-not-supported)). 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/strict-tool-use) oder [strukturierten Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs). 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](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use). ### Output-Limits Jedes Modell akzeptiert `max_tokens` bis zur hier aufgeführten Obergrenze. Auf der [Message Batches API](https://platform.claude.com/docs/de/build-with-claude/batch-processing#extended-output-beta) hebt der [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `output-300k-2026-03-24` diese Obergrenze für die Modelle an, bei denen eine Batches-Obergrenze aufgeführt ist. | Model | Max output tokens | Batches beta ceiling | | :-------------------- | :---------------- | :------------------- | | Claude Fable 5.1 | 128K | — | | Claude Mythos 5.1 | 128K | — | | Claude Fable 5 | 128K | — | | Claude Mythos 5 | 128K | — | | Claude Mythos Preview | 128K | Not available | | Claude Opus 5.5 | 128K | 300K | | Claude Opus 5 | 128K | 300K | | Claude Opus 4.8 | 128K | 300K | | Claude Opus 4.7 | 128K | 300K | | Claude Opus 4.6 | 128K | 300K | | Claude Opus 4.5 | 64K | Not available | | Claude Sonnet 5.5 | 128K | 300K | | Claude Sonnet 5 | 128K | 300K | | Claude Sonnet 4.6 | 128K | 300K | | Claude Sonnet 4.5 | 64K | Not available | | Claude Haiku 5.5 | 128K | 300K | | Claude Haiku 4.5 | 64K | Not available | Siehe die [Modellübersicht](https://platform.claude.com/docs/de/models/overview) 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()` (java: `.createStreaming()`; csharp: `.CreateStreaming()`; go: `.NewStreaming()`; php: `->createStream()`) mit `.get_final_message()` (typescript: `.finalMessage()`; ruby: `.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`), um das vollständige `Message`-Objekt zu erhalten, ohne es selbst aus einzelnen Events zusammenzusetzen. Siehe [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming#get-the-final-message-without-handling-events). 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](https://platform.claude.com/docs/de/build-with-claude/batch-processing), 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 Steuere, wie oft und wie tief Claude denkt, mit Effort-Stufen, System-Prompt-Anleitung und Steuerung pro Nachricht, und verstehe die Kosten und Preise von Thinking. Gehe einen vollständigen Tool-Nutzungs-Roundtrip über zwei Turns durch, der Thinking-Blöcke korrekt bewahrt, und sieh, wie verschachteltes Thinking den Ablauf verändert. Finde heraus, ob deine Messages-API-Integration den Konversationsverlauf bearbeitet, und ersetze jede Bearbeitung durch das API-Feature, das frühere Thinking-Blöcke gültig hält. Diagnostiziere und behebe die häufigsten Thinking-Fehler: 400-Konfigurationsfehler, leere oder fehlende Thinking-Blöcke, max\_tokens-Stopps und Cache-Misses. Steuere mit dem Effort-Parameter, wie viele Token Claude beim Antworten verwendet, und wäge zwischen Gründlichkeit der Antwort und Token-Effizienz ab.