Adaptives Denken

This feature is eligible for Zero Data Retention (ZDR). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.

Adaptives Denken ist die empfohlene Methode zur Verwendung von erweitertem Denken mit Claude Opus 4.7, Claude Opus 4.6 und Claude Sonnet 4.6 und ist der Standardmodus auf Claude Mythos Preview (wo es automatisch angewendet wird, wenn thinking nicht gesetzt ist). Anstatt manuell ein Denk-Token-Budget festzulegen, ermöglicht adaptives Denken Claude, dynamisch zu bestimmen, wann und wie viel erweitertes Denken basierend auf der Komplexität jeder Anfrage verwendet werden soll. Bei Claude Opus 4.7 ist adaptives Denken der einzige unterstützte Denkmodus; manuelles thinking: {type: "enabled", budget_tokens: N} wird nicht mehr akzeptiert.

Adaptives Denken kann bei vielen Workloads eine bessere Leistung als erweitertes Denken mit einem festen budget_tokens bieten, besonders bei bimodalen Aufgaben und langfristigen agentengesteuerten Workflows. Es ist kein Beta-Header erforderlich.

Wenn Ihre Workload vorhersehbare Latenz oder präzise Kontrolle über Denkkosten erfordert, ist erweitertes Denken mit budget_tokens auf Claude Opus 4.6 und Claude Sonnet 4.6 noch funktionsfähig, wird aber nicht mehr empfohlen und ist veraltet. Siehe die Warnung unten.

Unterstützte Modelle

Adaptives Denken wird auf den folgenden Modellen unterstützt:

Claude Mythos Preview (claude-mythos-preview), adaptives Denken ist der Standard; thinking: {type: "disabled"} wird nicht unterstützt
Claude Opus 4.7 (claude-opus-4-7), adaptives Denken ist der einzige unterstützte Denkmodus. Denken ist deaktiviert, es sei denn, Sie setzen explizit thinking: {type: "adaptive"} in Ihrer Anfrage; manuelles thinking: {type: "enabled"} wird mit einem 400-Fehler abgelehnt.
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 4.6 (claude-sonnet-4-6)

thinking.type: "enabled" und budget_tokens sind veraltet auf Opus 4.6 und Sonnet 4.6 und werden in einer zukünftigen Modellversion entfernt. Verwenden Sie stattdessen thinking.type: "adaptive" mit dem effort-Parameter. Bestehende budget_tokens-Konfigurationen funktionieren noch, werden aber nicht mehr empfohlen; planen Sie eine Migration.

Ältere Modelle (Sonnet 4.5, Opus 4.5 usw.) unterstützen adaptives Denken nicht und erfordern thinking.type: "enabled" mit budget_tokens.

Wie adaptives Denken funktioniert

Im adaptiven Modus ist Denken für das Modell optional. Claude bewertet die Komplexität jeder Anfrage und bestimmt, ob und wie viel erweitertes Denken verwendet werden soll. Auf der Standard-Anstrengungsstufe (high) denkt Claude fast immer. Bei niedrigeren Anstrengungsstufen kann Claude das Denken bei einfacheren Problemen überspringen.

Adaptives Denken aktiviert auch automatisch verschachteltes Denken. Dies bedeutet, dass Claude zwischen Werkzeugaufrufen denken kann, was es besonders effektiv für agentengesteuerte Workflows macht.

Wie man adaptives Denken verwendet

Setzen Sie thinking.type auf "adaptive" in Ihrer API-Anfrage:

Adaptives Denken mit dem Anstrengungsparameter

Sie können adaptives Denken mit dem Anstrengungsparameter kombinieren, um zu steuern, wie viel Claude denkt. Die Anstrengungsstufe dient als sanfte Anleitung für Claudes Denkzuteilung:

Anstrengungsstufe	Denkverhalten
`max`	Claude denkt immer ohne Einschränkungen auf die Denktiefe. Verfügbar auf Claude Mythos Preview, Claude Opus 4.7, Claude Opus 4.6 und Claude Sonnet 4.6.
`xhigh`	Claude denkt immer tief mit erweiterter Erkundung. Verfügbar auf Claude Opus 4.7.
`high` (Standard)	Claude denkt immer. Bietet tiefes Denken bei komplexen Aufgaben.
`medium`	Claude verwendet moderates Denken. Kann das Denken bei sehr einfachen Anfragen überspringen.
`low`	Claude minimiert das Denken. Überspringt das Denken bei einfachen Aufgaben, bei denen Geschwindigkeit am wichtigsten ist.

Streaming mit adaptivem Denken

Adaptives Denken funktioniert nahtlos mit Streaming. Denkblöcke werden über thinking_delta-Ereignisse gestreamt, genau wie im manuellen Denkmodus:

Adaptives vs. manuelles vs. deaktiviertes Denken

Modus	Konfiguration	Verfügbarkeit	Wann zu verwenden
Adaptiv	`thinking: {type: "adaptive"}`	Claude Mythos Preview (Standard), Opus 4.7 (nur Modus), Opus 4.6, Sonnet 4.6	Claude bestimmt, wann und wie viel erweitertes Denken verwendet werden soll. Verwenden Sie `effort` zur Anleitung.
Manuell	`thinking: {type: "enabled", budget_tokens: N}`	Alle Modelle außer Claude Opus 4.7 (abgelehnt). Veraltet auf Opus 4.6 und Sonnet 4.6 (erwägen Sie stattdessen adaptiven Modus).	Wenn Sie präzise Kontrolle über die Denktoken-Ausgaben benötigen.
Deaktiviert	Lassen Sie den `thinking`-Parameter weg oder übergeben Sie `{type: "disabled"}`	Alle Modelle außer Claude Mythos Preview	Wenn Sie kein erweitertes Denken benötigen und die niedrigste Latenz wünschen.

Adaptives Denken ist auf Claude Mythos Preview, Claude Opus 4.7, Opus 4.6 und Sonnet 4.6 verfügbar. Bei Mythos Preview ist adaptives Denken der Standard und wird automatisch angewendet, wenn thinking nicht gesetzt ist. Bei Claude Opus 4.7 ist adaptives Denken der einzige unterstützte Modus und type: "enabled" mit budget_tokens wird abgelehnt. Ältere Modelle unterstützen nur type: "enabled" mit budget_tokens. Bei Opus 4.6 und Sonnet 4.6 ist type: "enabled" mit budget_tokens noch funktionsfähig, aber veraltet.

Verfügbarkeit von verschachteltem Denken nach Modus:

Adaptiver Modus: Verschachteltes Denken wird automatisch auf Claude Mythos Preview, Claude Opus 4.7, Opus 4.6 und Sonnet 4.6 aktiviert. Bei Mythos Preview und Opus 4.7 befindet sich das Denken zwischen Werkzeugen immer in Denkblöcken.
Manueller Modus auf Sonnet 4.6: Verschachteltes Denken funktioniert über den interleaved-thinking-2025-05-14-Beta-Header.
Manueller Modus auf Opus 4.6: Verschachteltes Denken ist nicht verfügbar. Wenn Ihr agentengesteuerter Workflow Denken zwischen Werkzeugaufrufen auf Opus 4.6 erfordert, verwenden Sie adaptiven Modus.

Wichtige Überlegungen

Validierungsänderungen

Bei Verwendung von adaptivem Denken müssen vorherige Assistent-Turns nicht mit Denkblöcken beginnen. Dies ist flexibler als der manuelle Modus, bei dem die API erzwingt, dass Turns mit aktiviertem Denken mit einem Denkblock beginnen.

Prompt-Caching

Aufeinanderfolgende Anfragen mit adaptive-Denken bewahren Prompt-Cache-Haltepunkte. Das Wechseln zwischen adaptive- und enabled/disabled-Denkmodi bricht jedoch Cache-Haltepunkte für Nachrichten. Systemaufforderungen und Werkzeugdefinitionen bleiben unabhängig von Modusänderungen zwischengespeichert.

Abstimmung des Denkverhaltens

Das Auslöseverhalten von adaptivem Denken ist aufforderbar. Wenn Claude häufiger oder seltener denkt, als Sie möchten, können Sie Ihrer Systemaufforderung Anleitung hinzufügen:

Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.

Das Lenken von Claude zu weniger häufigem Denken kann die Qualität bei Aufgaben verringern, die von Denken profitieren. Messen Sie die Auswirkungen auf Ihre spezifischen Workloads, bevor Sie promptbasierte Abstimmung in der Produktion bereitstellen. Erwägen Sie zunächst Tests mit niedrigeren Anstrengungsstufen.

Kostenkontrolle

Verwenden Sie max_tokens als harte Grenze für die Gesamtausgabe (Denken + Antworttext). Der effort-Parameter bietet zusätzliche sanfte Anleitung zur Denkzuteilung durch Claude. Zusammen geben diese Ihnen effektive Kontrolle über die Kosten.

Bei high- und max-Anstrengungsstufen kann Claude umfangreicher denken und ist eher geneigt, das max_tokens-Budget auszuschöpfen. Wenn Sie stop_reason: "max_tokens" in Antworten beobachten, erwägen Sie, max_tokens zu erhöhen, um dem Modell mehr Platz zu geben, oder senken Sie die Anstrengungsstufe.

Arbeiten mit Denkblöcken

Die folgenden Konzepte gelten für alle Modelle, die erweitertes Denken unterstützen, unabhängig davon, ob Sie adaptiven oder manuellen Modus verwenden.

Zusammengefasstes Denken

With extended thinking enabled, the Messages API for Claude 4 models returns a summary of Claude's full thinking process. Summarized thinking provides the full intelligence benefits of extended thinking, while preventing misuse. This is the default behavior on Claude 4 models when the display field on the thinking configuration is unset or set to "summarized". On Claude Opus 4.7 and Claude Mythos Preview, display defaults to "omitted" instead, so you must set display: "summarized" explicitly to receive summarized thinking.

Here are some important considerations for summarized thinking:

You're charged for the full thinking tokens generated by the original request, not the summary tokens.
The billed output token count will not match the count of tokens you see in the response.
On Claude 4 models, the first few lines of thinking output are more verbose, providing detailed reasoning that's particularly helpful for prompt engineering purposes. Claude Mythos Preview summarizes from the first token, so its thinking blocks do not show this verbose preamble.
As Anthropic seeks to improve the extended thinking feature, summarization behavior is subject to change.
Summarization preserves the key ideas of Claude's thinking process with minimal added latency, enabling a streamable user experience.
Summarization is processed by a different model than the one you target in your requests. The thinking model does not see the summarized output.

In rare cases where you need access to full thinking output for Claude 4 models, contact Anthropic sales.

Kontrolle der Denkdarstellung

The display field on the thinking configuration controls how thinking content is returned in API responses. It accepts two values:

"summarized": Thinking blocks contain summarized thinking text. See Summarized thinking for details. This is the default on Claude Opus 4.6, Claude Sonnet 4.6, and earlier Claude 4 models.
"omitted": Thinking blocks are returned with an empty thinking field. The signature field still carries the encrypted full thinking for multi-turn continuity (see Thinking encryption). This is the default on Claude Opus 4.7 and Claude Mythos Preview.

Setting display: "omitted" is useful when your application doesn't surface thinking content to users. The primary benefit is faster time-to-first-text-token when streaming: The server skips streaming thinking tokens entirely and delivers only the signature, so the final text response begins streaming sooner.

Here are some important considerations for omitted thinking:

You're still charged for the full thinking tokens. Omitting reduces latency, not cost.
If you pass thinking blocks back in multi-turn conversations, pass them unchanged. The server decrypts the signature to reconstruct the original thinking for prompt construction (see Preserving thinking blocks). Any text you place in the thinking field of a round-tripped omitted block is ignored.
display is invalid with thinking.type: "disabled" (there is nothing to display).
When using thinking.type: "adaptive" and the model skips thinking for a simple request, no thinking block is produced regardless of display.

The signature field is identical whether display is "summarized" or "omitted". Switching display values between turns in a conversation is supported.

Bei Claude Opus 4.7 ist thinking.display standardmäßig auf "omitted" eingestellt. Denkblöcke erscheinen immer noch im Antwort-Stream, aber ihr thinking-Feld ist leer, es sei denn, Sie entscheiden sich explizit dafür. Dies ist eine stille Änderung von Claude Opus 4.6, wo der Standard "summarized" war. Um zusammengefasstes Denktext auf Claude Opus 4.7 wiederherzustellen, setzen Sie thinking.display explizit auf "summarized":

thinking = {
    "type": "adaptive",
    "display": "summarized",
}

Für Codebeispiele und Streaming-Verhalten mit display: "omitted" siehe Kontrolle der Denkdarstellung auf der Seite zum erweiterten Denken. Die Beispiele dort verwenden type: "enabled"; verwenden Sie mit adaptivem Denken:

thinking = {"type": "adaptive", "display": "omitted"}

Denkverschlüsselung

Full thinking content is encrypted and returned in the signature field. This field is used to verify that thinking blocks were generated by Claude when passed back to the API.

It is only strictly necessary to send back thinking blocks when using tools with extended thinking. Otherwise you can omit thinking blocks from previous turns. If you pass them back, whether the API keeps or strips them depends on the model: Opus 4.5+ and Sonnet 4.6+ keep them in context by default; earlier Opus/Sonnet models and all Haiku models strip them. See context editing to configure this.

If sending back thinking blocks, pass everything back as you received it for consistency and to avoid potential issues.

Here are some important considerations on thinking encryption:

When streaming responses, the signature is added via a signature_delta inside a content_block_delta event just before the content_block_stop event.
signature values are significantly longer in Claude 4 models than in previous models.
The signature field is an opaque field and should not be interpreted or parsed.
signature values are compatible across platforms (Claude APIs, Amazon Bedrock, and Vertex AI). Values generated on one platform will be compatible with another.

Preisgestaltung

For complete pricing information including base rates, cache writes, cache hits, and output tokens, see the pricing page.

The thinking process incurs charges for:

Tokens used during thinking (output tokens)
Thinking blocks from prior assistant turns kept in context: only the last turn on earlier Opus/Sonnet models and all Haiku models; all turns by default on Opus 4.5+ and Sonnet 4.6+ (input tokens)
Standard text output tokens

When extended thinking is enabled, a specialized system prompt is automatically included to support this feature.

When using summarized thinking:

Input tokens: Tokens in your original request (excludes thinking tokens from previous turns)
Output tokens (billed): The original thinking tokens that Claude generated internally
Output tokens (visible): The summarized thinking tokens you see in the response
No charge: Tokens used to generate the summary

When using display: "omitted":

Input tokens: Tokens in your original request (same as summarized)
Output tokens (billed): The original thinking tokens that Claude generated internally (same as summarized)
Output tokens (visible): Zero thinking tokens (the thinking field is empty)

The billed output token count will not match the visible token count in the response. You are billed for the full thinking process, not the thinking content visible in the response.

Zusätzliche Themen

Die Seite zum erweiterten Denken behandelt mehrere Themen ausführlicher mit modellspezifischen Codebeispielen:

Werkzeugverwendung mit Denken: Die gleichen Regeln gelten für adaptives Denken: Bewahren Sie Denkblöcke zwischen Werkzeugaufrufen und beachten Sie tool_choice-Einschränkungen, wenn Denken aktiv ist.
Prompt-Caching: Mit adaptivem Denken bewahren aufeinanderfolgende Anfragen mit dem gleichen Denkmodus Cache-Haltepunkte. Das Wechseln zwischen adaptive- und enabled/disabled-Modi bricht Cache-Haltepunkte für Nachrichten (Systemaufforderungen und Werkzeugdefinitionen bleiben zwischengespeichert).
Kontextfenster: Wie Denktoken mit max_tokens und Kontextfenstergrenzen interagieren.

Nächste Schritte

Erweitertes Denken

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even.",
        }
    ],
)

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

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "medium"},
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(response.content[0].text)

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    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)