Nachdenken steuern

Claudes „thinking“ (Nachdenken) ist adaptiv: Das Modell bewertet jede Anfrage und entscheidet, ob und wie viel es nachdenkt. Du legst eine Absicht fest, gibst optional den Effort an, und das Modell setzt Reasoning dort ein, wo es dieses für hilfreich hält.

Das macht Nachdenken zu einer guten Wahl für Workloads, die triviale und komplexe Anfragen mischen, sowie für agentische Workflows mit langem Horizont, bei denen die richtige Menge an Reasoning von Schritt zu Schritt variiert.

Wie du Nachdenken aktivierst, wie du die Ausgabe des Nachdenkens liest und was es mit der Ausgabe des Nachdenkens bei Claude Fable 5 und Claude Mythos 5 auf sich hat, erfährst du in der Übersicht zu Nachdenken. Diese Seite behandelt, wie Claude entscheidet, wann es nachdenkt, wie du das Nachdenken steuerst und welche Mechanismen für Caching, Kosten und Preise sich daraus ergeben.

Wie Claude entscheidet, wann es nachdenkt

Nachdenken ist für das Modell optional. Bei jeder Anfrage wägt Claude die Komplexität der Eingabe ab und entscheidet, ob tieferes Reasoning die Antwort verbessern würde. Eine einfache Faktenfrage erhält möglicherweise eine direkte Antwort ganz ohne „thinking block“ (Thinking-Block); ein mehrstufiges Mathematikproblem oder eine knifflige Debugging-Aufgabe löst tieferes Reasoning aus.

Die Entscheidung fällt pro Anfrage. Dieselbe Konversation kann Turns mit und ohne Nachdenken enthalten, und ein Turn, in dem Claude sich entschieden hat, nicht zu denken, enthält keinen Thinking-Block. Baue keine Anwendungslogik, die davon ausgeht, dass jeder Assistant-Turn mit einem beginnt.

Die primäre Kontrolle über diese Entscheidung ist der Parameter effort, der als weiche Vorgabe dafür dient, wie bereitwillig und wie tief Claude denken soll; siehe Effort-Stufen auf dieser Seite für die Wirkung jeder Stufe.

Wenn du möchtest, dass Claude seltener denkt, senke zuerst die Effort-Stufe, bevor du zu Prompt-basierter Steuerung greifst.

Nachdenken verschränkt sich außerdem automatisch mit der „tool use“ (Tool-Nutzung): Claude kann zwischen Tool-Aufrufen nachdenken und jedes Tool-Ergebnis reflektieren, bevor es entscheidet, was als Nächstes zu tun ist (verschachteltes Nachdenken). Dafür brauchst du weder einen Beta-Header noch zusätzliche Konfiguration.

Das vollständige Bild, wie die Thinking-Konfiguration und der Effort-Parameter zusammenwirken, findest du unter Nachdenken und Effort.

Steuern, wie oft Claude denkt

Ob Claude in einem bestimmten Turn denkt, lässt sich per Prompt beeinflussen. Effort legt die Grundhaltung fest, aber du kannst die Entscheidung auch direkt mit Anweisungen in natürlicher Sprache formen, entweder global im „system prompt“ (System-Prompt) oder pro Nachricht aus dem User-Turn.

Verwende die beiden Hebel gemeinsam in dieser Reihenfolge:

1. Setze die Effort-Stufe, die zur Standardbalance deines Workloads zwischen Qualität und Latenz passt.
2. Füge Prompt-Anleitungen nur hinzu, wenn Claudes Auslöseverhalten auf dieser Stufe immer noch nicht deinen Anforderungen entspricht.

Umfassendere Prompting-Hinweise zum Nachdenken findest du unter Nutze die Fähigkeiten für Nachdenken und verschachteltes Nachdenken.

Effort-Stufen

Effort ist der primäre Steuerungshebel für das Nachdenken. Jede Stufe setzt einen anderen Standard dafür, wie oft und wie tief Claude denkt:

Auf jeder Stufe entscheidet Claude pro Anfrage, ob es nachdenkt. In einer Tool-Nutzungs-Schleife trägt typischerweise die erste Anfrage nach einer neuen Benutzereingabe den Großteil des Reasonings, und Folgeanfragen, die nur Tool-Ergebnisse verarbeiten, können das Nachdenken überspringen, auch bei xhigh und max. Das Nachdenken pro Anfrage nimmt außerdem tendenziell ab, je länger eine Konversation wird. Keine Stufe garantiert einen Thinking-Block bei jeder Anfrage.

Diese Tabelle beschreibt, wie jede Stufe das Denkverhalten verändert. Hinweise dazu, welche Stufe du für einen bestimmten Workload wählen solltest, einschließlich modellspezifischer Empfehlungen, findest du unter Wann der Effort-Parameter angepasst werden sollte auf der Effort-Seite.

Effort wird unter output_config.effort gesetzt, nicht innerhalb des thinking-Objekts; vollständige Beispiele pro Sprache findest du unter Effort.

{
  "model": "claude-opus-5-5",
  "max_tokens": 4096,
  "output_config": { "effort": "medium" },
  "messages": [{ "role": "user", "content": "..." }]
}

Die Verfügbarkeit der Stufen variiert je nach Modell; die Effort-Verfügbarkeitstabelle auf der Effort-Seite ist maßgeblich dafür, welche Stufen jedes Modell unterstützt.

System-Prompt-Anleitungen

Anleitungen im System-Prompt verschieben Claudes Denkschwelle für jede Anfrage in der Konversation. Wenn Claude häufiger denkt, als dein Workload es erfordert, füge deinem System-Prompt eine Anleitung wie diese hinzu:

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

Um stattdessen zum Nachdenken zu ermutigen, verwende eine Formulierung wie:

This task involves multistep reasoning. Think carefully before responding.

Die Wirksamkeit der Steuerung kann empfindlich auf die genaue Wortwahl reagieren. Wenn eine Formulierung nicht das gewünschte Verhalten erzeugt, probiere eine direktere Variante.

Nachrichtenbezogene Steuerung

Du kannst das Nachdenken auch pro Nachricht aus dem User-Turn steuern, unabhängig vom System-Prompt. Das Anhängen von "Please think hard before responding." an eine User-Nachricht ermutigt Claude, in diesem Turn nachzudenken; "Answer directly without deliberating." hält Claude davon ab.

Steuerung pro Nachricht ist nützlich, wenn nur einige Anfragen in einer Konversation ausgedehntes Reasoning rechtfertigen. Ein Agent-Harness kann beispielsweise bei Planungsschritten die ermutigende Formulierung und bei Routinebestätigungen die bremsende Formulierung anhängen, ohne den System-Prompt anzufassen oder zwischen den Turns Anfrageparameter zu ändern.

Bei Claude Haiku 5.5 reduziert die bremsende Formulierung das Nachdenken nicht zuverlässig. Auf der Claude API und Google Cloud führst du Routine-Turns auf diesem Modell mit weniger Nachdenken aus, indem du stattdessen eine Effort-Änderung pro Nachricht (Beta) verwendest, die außerdem den Prompt-Cache erhält.

Steuerung an deinem Workload überprüfen

Prompt-basierte Steuerung verändert das Modellverhalten, behandle sie also wie jede andere Prompt-Änderung: Miss, bevor du auslieferst. Führe eine repräsentative Stichprobe deines Traffics mit und ohne die Anleitung aus und vergleiche, wie oft Nachdenken ausgelöst wird (das Vorhandensein von Thinking-Blöcken in Antworten), die Nutzung von Output-Token, die Latenz und die Antwortqualität bei den Fällen, die dir wichtig sind.

Mechaniken

Drei Mechaniken ergeben sich daraus, dass Claude sein Nachdenken selbst verwaltet: Turn-Validierung, Prompt-Caching und wie du die Kosten begrenzt.

Turn-Validierung

Assistant-Turns müssen nicht mit einem Thinking-Block beginnen. (Modelle, die ein veraltetes manuelles Thinking-Budget verwenden, erzwingen, dass der letzte Assistant-Turn einer Anfrage mit aktiviertem Nachdenken mit einem beginnt; siehe Turn-Struktur im manuellen Modus.)

Für Multi-Turn-Anwendungen bedeutet das, dass du den Konversationsverlauf in beliebiger Form zurückgeben kannst:

• Assistant-Turns, in denen Claude sich entschieden hat, nicht zu denken, sind unverändert gültiger Verlauf.
• Du kannst eine Konversation fortsetzen, die ohne Nachdenken begonnen hat oder eine andere Thinking-Konfiguration verwendet hat, ohne ihren Verlauf umzuschreiben.
• Ein aus gemischten Quellen zusammengesetzter Verlauf benötigt keine wieder eingefügten Thinking-Blöcke am Anfang jedes Assistant-Turns, um die Validierung zu bestehen.

Die Lockerung betrifft die Validierung, nicht das, was du senden solltest. Wenn du Thinking-Blöcke hast, gib sie unverändert zurück, insbesondere während der Tool-Nutzung, wo sie das Reasoning hinter Claudes Tool-Aufrufen tragen. Die vollständigen Regeln findest du in der Übersicht Nachdenken.

Prompt-Caching

Aufeinanderfolgende Anfragen, die dieselbe Thinking-Konfiguration und Effort-Stufe beibehalten, erhalten das „prompt caching“ (Prompt-Caching); die vollständigen Regeln findest du unter Nachdenken und Prompt-Caching. Der aufgelöste Effort-Wert wird in den Prompt gerendert, sodass eine Änderung zwischen Anfragen Cache-Breakpoints invalidiert, genau wie eine Änderung des veralteten Parameters budget_tokens bei Modellen, die ihn verwenden. effort explizit auf den Standardwert des Modells zu setzen, ist gleichbedeutend mit dem Weglassen und bricht den Cache nicht.

Die praktische Konsequenz: Wähle pro Konversation eine Thinking-Konfiguration und eine Effort-Stufe auf oberster Ebene und behalte sie bei. Wenn einige Turns mehr oder weniger Nachdenken benötigen, verwende bei Modellen, die dies unterstützen, eine Effort-Änderung pro Nachricht (Beta) oder steuere mit Prompting pro Nachricht. Beide lassen frühere Cache-Breakpoints intakt, während eine Änderung der Thinking-Konfiguration oder der Effort-Stufe auf oberster Ebene dies nicht tut.

Das folgende Beispiel demonstriert die Invalidierung mit einem Multi-Turn-Skript, das du selbst ausführen kannst:

import requests

client = Anthropic()


def fetch_article_content(url):
    text = requests.get(url).text
    lines = (line.strip() for line in text.splitlines())
    return "\n".join(line for line in lines if line)


# Lade den Inhalt des Artikels
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Verwende gerade genug Text für das Caching (die ersten Kapitel)
LARGE_TEXT = book_content[:10000]

# Kein System-Prompt – Caching stattdessen in den Nachrichten
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {"type": "text", "text": "Analyze the tone of this passage."},
        ],
    }
]

# Erste Anfrage – Cache anlegen
print("First request - establishing cache")
response1 = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=MESSAGES,
)

print(f"First response usage: {response1.usage}")

MESSAGES.append({"role": "assistant", "content": response1.content})
MESSAGES.append({"role": "user", "content": "Analyze the characters in this passage."})

# Zweite Anfrage – gleiche Konfiguration (Cache-Treffer erwartet)
print("\nSecond request - same configuration (cache hit expected)")
response2 = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=MESSAGES,
)

print(f"Second response usage: {response2.usage}")

MESSAGES.append({"role": "assistant", "content": response2.content})
MESSAGES.append({"role": "user", "content": "Analyze the setting in this passage."})

# Dritte Anfrage – anderes Effort-Level (Cache-Fehltreffer erwartet)
print("\nThird request - different effort level (cache miss expected)")
response3 = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    output_config={"effort": "low"},
    messages=MESSAGES,
)

print(f"Third response usage: {response3.usage}")

First request - establishing cache
First response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 15, output_tokens: 1033 }

Second request - same configuration (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 3546, input_tokens: 1062, output_tokens: 1630 }

Third request - different effort level (cache miss expected)
Third response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 2706, output_tokens: 1468 }

Kostenkontrolle

Du legst kein Thinking-Token-Budget fest. Zwei Kontrollen begrenzen die Kosten:

• max_tokens ist eine harte Obergrenze für die gesamte Ausgabe der Anfrage, Nachdenken und Antworttext zusammen. Claude generiert nie darüber hinaus. In einer Tool-Use-Schleife hat jede Anfrage im Turn ihr eigenes max_tokens, sodass es nicht die Ausgaben des gesamten Turns begrenzt.
• effort ist eine weiche Vorgabe dafür, wie viel dieser Ausgabe Claude dem Nachdenken zuweist. Es formt das Verhalten, garantiert aber keine Token-Anzahl.

Da Nachdenken auf max_tokens angerechnet wird, setze es hoch genug, um Platz sowohl für das Reasoning als auch für die Antwort zu lassen. Ein max_tokens, das für eine Antwort ohne Nachdenken bemessen ist, ist oft zu klein, sobald Claude bei schwierigen Anfragen zu denken beginnt.

Bei Effort high und darüber kann Claude ausgiebig denken und schöpft das Budget mit höherer Wahrscheinlichkeit aus. Wenn du stop_reason: "max_tokens" in Antworten siehst, hast du zwei Abhilfen:

• Erhöhe max_tokens, um dem Modell mehr Platz für Nachdenken plus Antwort zu geben.
• Senke die Effort-Stufe, damit Claude weniger denkt und mehr vom Budget für Antworttext übrig lässt.

Welche die richtige ist, hängt davon ab, ob die abgeschnittenen Antworten das Reasoning benötigten. Wenn die Qualität bei diesen Anfragen wichtig ist, erhöhe die Obergrenze; wenn sie überdacht waren, senke den Effort.

Preisgestaltung

Nachdenken verursacht Kosten für:

• Token, die Claude beim Nachdenken verwendet (als Output-Token abgerechnet)
• Thinking-Blöcke aus früheren Assistant-Turns, die im Kontext verbleiben, gemäß dem Standard zur Beibehaltung: standardmäßig alle Turns bei Keep-All-Modellen, andernfalls nur der letzte Turn (als Input-Token abgerechnet)
• Standardmäßige Text-Output-Token

Was dir in Rechnung gestellt wird, ist unabhängig von der display-Einstellung gleich; nur was du siehst, ändert sich:

Um zu sehen, wie viele abgerechnete Output-Token für internes Reasoning aufgewendet wurden, lies usage.output_tokens_details.thinking_tokens in der Antwort. Dieser Wert spiegelt das rohe Reasoning wider, das das Modell generiert hat (nicht den im Body zurückgegebenen zusammengefassten Text), und ist immer kleiner oder gleich output_tokens. Ziehe ihn von output_tokens ab, um den Nicht-Reasoning-Anteil der Ausgabe anzunähern. Beim Streaming erscheint diese Aufschlüsselung nur im abschließenden message_delta-Event.

{
  "usage": {
    "input_tokens": 25,
    "output_tokens": 348,
    "output_tokens_details": {
      "thinking_tokens": 312
    }
  }
}

output_tokens bleibt die inklusive, maßgebliche Gesamtsumme, die für die Abrechnung verwendet wird. output_tokens_details ist eine schreibgeschützte Aufschlüsselung zur Beobachtbarkeit. Vollständige Preisinformationen einschließlich Basistarifen, Cache-Writes, Cache-Hits und Output-Token findest du unter Preisgestaltung.

Nächste Schritte