---
title: Erweitertes Nachdenken
url: https://platform.claude.com/docs/de/build-with-claude/extended-thinking
description: Konfiguriere manuelles erweitertes Nachdenken mit einem festen budget_tokens-Budget auf Claude-Modellen, die es unterstützen, und migriere zu adaptivem Nachdenken.
---

<Note>
  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).
</Note>

<Warning>
  „Extended thinking“ (erweitertes Nachdenken) (`thinking.type: "enabled"` mit `budget_tokens`) ist auf den Claude 4.6-Modellen abgekündigt (Anfragen, die es verwenden, sind weiterhin erfolgreich). Claude 4.7 und spätere Modelle unterstützen es nicht und lehnen Anfragen, die es verwenden, mit einem 400-Fehler ab. Auf Claude 4.5 und früheren Modellen, die Nachdenken unterstützen, ist erweitertes Nachdenken der einzige verfügbare Denkmodus. Claude Mythos Preview unterstützt beide Modi. Wo beide Modi verfügbar sind, verwende stattdessen [adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking).

  Siehe [Migration zu adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#migrating-to-adaptive-thinking), um zu adaptivem Nachdenken zu wechseln. Wenn dein Modell nur erweitertes Nachdenken unterstützt, beschreibt diese Seite die unterstützte Konfiguration; es ist keine Änderung nötig, bis du zu einem neueren Modell wechselst.
</Warning>

<Note>
  Wenn eine Anfrage mit einem 400-Fehler fehlschlägt, dessen Meldung mit `"thinking.type.enabled" is not supported` beginnt, verwendet dein Modell stattdessen adaptives Nachdenken. Siehe [Fehlerbehebung beim Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#error-thinking-type-enabled) oder springe direkt zu [Migration zu adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).
</Note>

„Extended thinking“ (erweitertes Nachdenken) im manuellen Modus gibt dir direkte Kontrolle darüber, wie viel Claude nachdenkt. Du legst bei jeder Anfrage mit `thinking: {type: "enabled", budget_tokens: N}` ein Token-Budget für das Nachdenken fest, und Claude denkt im Rahmen dieses Budgets nach, bevor es mit seiner endgültigen Antwort beginnt. Der manuelle Modus bleibt nützlich, wenn dein Workload vorhersagbare Latenz oder präzise Kontrolle über die Denkkosten erfordert. Diese Seite behandelt, wie du das Budget festlegst und abstimmst, wie der manuelle Modus mit „interleaved thinking“ (verschränktem Nachdenken) und „prompt caching“ (Prompt-Caching) zusammenspielt und wie du zu adaptivem Nachdenken migrierst.

Um zu erfahren, wie das Nachdenken selbst funktioniert, einschließlich Thinking-Blöcken und der Antwortstruktur, des `display`-Parameters, Streaming, Nachdenken mit Tool-Nutzung und Verschlüsselung, siehe die [Übersicht zum Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking).

## Unterstützte Modelle

Die Verfügbarkeit von erweitertem Nachdenken pro Modell, einschließlich der Modelle, bei denen erweitertes Nachdenken der einzige Modus ist, ist in der [Konfigurationstabelle pro Modell](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#supported-models) aufgeführt.

## So verwendest du erweitertes Nachdenken

Hier ist ein Beispiel für die Verwendung von erweitertem Nachdenken in der Messages API:

<CodeGroup>
  ```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-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create \
    --format yaml <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: Are there an infinite number of prime numbers such that n mod 4 == 3?
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[
          {
              "role": "user",
              "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          }
      ],
  )

  # Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking summary: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      {
        role: "user",
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  });

  // Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking summary: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new()
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages =
      [
          new()
          {
              Role = Role.User,
              Content = "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          },
      ],
  });

  // Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  foreach (var block in response.Content)
  {
      if (block.TryPickThinking(out var thinking))
      {
          Console.WriteLine($"\nThinking summary: {thinking.Thinking}");
      }
      else if (block.TryPickText(out var text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  for _, block := range response.Content {
  	switch block := block.AsAny().(type) {
  	case anthropic.ThinkingBlock:
  		fmt.Printf("\nThinking summary: %s", block.Thinking)
  	case anthropic.TextBlock:
  		fmt.Printf("\nResponse: %s", block.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      var client = AnthropicOkHttpClient.fromEnv();

      var params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_4_6)
          .maxTokens(16_000)
          .enabledThinking(10_000)
          .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
          .build();

      var response = client.messages().create(params);

      // Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
      for (var block : response.content()) {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking summary: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      }
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: 'claude-sonnet-4-6',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [
          [
              'role' => 'user',
              'content' => 'Are there an infinite number of prime numbers such that n mod 4 == 3?',
          ],
      ],
  );

  // Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  foreach ($response->content as $block) {
      echo match (true) {
          $block instanceof \Anthropic\Messages\ThinkingBlock => "\nThinking summary: {$block->thinking}",
          $block instanceof \Anthropic\Messages\TextBlock => "\nResponse: {$block->text}",
          default => '',
      };
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: "claude-sonnet-4-6",
    max_tokens: 16_000,
    thinking: {
      type: :enabled,
      budget_tokens: 10_000
    },
    messages: [
      {
        role: :user,
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  )

  # Die Antwort enthält zusammengefasste Thinking-Blöcke und Textblöcke
  response.content.each do |block|
    case block
    when Anthropic::Models::ThinkingBlock
      puts "\nThinking summary: #{block.thinking}"
    when Anthropic::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end
  ```
</CodeGroup>

Um manuelles erweitertes Nachdenken zu aktivieren, füge ein `thinking`-Objekt hinzu, bei dem `type` auf `enabled` gesetzt ist und das einen `budget_tokens`-Wert enthält.

Der Parameter `budget_tokens` legt ein Ziel dafür fest, wie viele Token Claude für seinen internen Denkprozess verwenden kann. Größere Budgets können die Antwortqualität verbessern, indem sie eine gründlichere Analyse komplexer Probleme ermöglichen.

## Budgetregeln und Abstimmung

`budget_tokens` muss diese Bedingungen erfüllen:

* **Minimum von 1.024 Token.** Die API lehnt kleinere Werte ab.
* **Kleiner als `max_tokens`.** Thinking-Token zählen zum `max_tokens`-Limit des Turns, daher muss das Budget Platz für die endgültige Antwort lassen. Die einzige Ausnahme ist [Interleaved Thinking](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#interleaved-thinking), bei dem `budget_tokens` `max_tokens` überschreiten kann, weil sich das Budget über alle Thinking-Blöcke innerhalb eines Assistant-Turns erstreckt.
* **Kein Vorwärmen des Caches.** Da `budget_tokens` kleiner als `max_tokens` sein muss, kann erweitertes Nachdenken nicht mit `max_tokens: 0` ([Vorwärmen des Caches](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#pre-warming-the-cache)) kombiniert werden.

Das Budget ist ein Zielwert und keine strikte Obergrenze. Der tatsächliche Token-Verbrauch variiert je nach Aufgabe, und Claude kann das Nachdenken deutlich vor Ausschöpfung des Budgets beenden; `max_tokens` bleibt die harte Obergrenze für die gesamte Ausgabe.

Auf Claude Opus 4.5, dem einzigen Modell mit ausschließlich erweitertem Nachdenken, das [Effort](https://platform.claude.com/docs/de/build-with-claude/effort) unterstützt, formt Effort die Gesamtantwort, während `budget_tokens` die Denktiefe festlegt; setze beides.

So stimmst du das Budget ab:

* Passe den Ausgangspunkt an die Aufgabe an. Beginne bei einfachen Aufgaben nahe dem Minimum von 1.024 Token und erhöhe schrittweise, um den optimalen Bereich für deinen Anwendungsfall zu finden. Beginne bei komplexen Aufgaben mit einem größeren Budget von 16.000 Token oder mehr und passe es an deine Latenz- und Qualitätsanforderungen an. Höhere Budgets ermöglichen umfassenderes Nachdenken, mit abnehmendem Grenznutzen, der von der Aufgabe abhängt, und auf Kosten erhöhter Latenz. Teste bei kritischen Aufgaben verschiedene Einstellungen, um die richtige Balance zu finden.
* Verwende für Denkbudgets über 32k die [Batch-Verarbeitung](https://platform.claude.com/docs/de/build-with-claude/batch-processing), um Netzwerkprobleme zu vermeiden. Wenn du das Modell dazu bringst, über 32k Token hinaus nachzudenken, entstehen lang laufende Anfragen, die auf System-Timeouts und Limits für offene Verbindungen stoßen können.

Um nachzuverfolgen, was ein Budget dich tatsächlich kostet, überwache das Feld `usage.output_tokens_details.thinking_tokens` in der Antwort, das angibt, wie viele der abgerechneten Ausgabe-Token internes Nachdenken waren. Beim Streaming erscheint diese Aufschlüsselung nur im abschließenden `message_delta`-Event.

Wenn du bereit bist, von manuellen Budgets wegzugehen, siehe [Migration zu adaptivem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).

## Interleaved Thinking im manuellen Modus

Interleaved Thinking ermöglicht es Claude, zwischen Tool-Aufrufen innerhalb eines einzelnen Assistant-Turns nachzudenken und über jedes Tool-Ergebnis zu reflektieren, bevor es entscheidet, was als Nächstes zu tun ist. Das Konzept, die Turn-Struktur und das Verhalten auf Modellen mit adaptivem Nachdenken findest du unter [verschachteltes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking#interleaved-thinking) in der Übersicht zum Nachdenken. Dieser Abschnitt behandelt, wie du es aktivierst, wenn du manuelles Nachdenken mit `type: "enabled"` verwendest.

Füge bei Claude Opus 4.5, Claude Sonnet 4.5 (abgekündigt) und früheren Claude-4-Modellen den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `interleaved-thinking-2025-05-14` zu deiner API-Anfrage hinzu.

Die 4.6-Generation teilt sich im manuellen Modus auf:

* **Claude Sonnet 4.6**: Der Beta-Header mit manuellem `type: "enabled"` funktioniert weiterhin, ist aber abgekündigt. Bevorzuge [adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking), das automatisch und ohne Header verschränkt.
* **Claude Opus 4.6**: Der manuelle Modus hat überhaupt kein Interleaved Thinking. Nur sein adaptiver Modus verschränkt, wechsle also zu `thinking: {type: "adaptive"}`, wenn du auf diesem Modell Nachdenken zwischen Tool-Aufrufen benötigst.

Claude Haiku 4.5 unterstützt kein Interleaved Thinking. Auf der Claude API wird der Beta-Header akzeptiert, aber ignoriert.

Zwei weitere Überlegungen zu Interleaved Thinking im manuellen Modus:

* `budget_tokens` kann hier `max_tokens` überschreiten; die [Budgetregeln](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#budget-rules-and-tuning) erklären diese Ausnahme.
* Interleaved Thinking 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).

Wie Plattformen den Beta-Header behandeln, unterscheidet sich. Die Claude API und [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) akzeptieren `interleaved-thinking-2025-05-14` auf jedem Modell und ignorieren ihn, wo er nicht unterstützt wird. Akzeptanz ist nicht dasselbe wie Wirkung: Auf Modellen, die `type: "enabled"` ablehnen (4.7 und später) oder kein Interleaving im manuellen Modus haben (Claude Opus 4.6), hat der Header keine Wirkung im manuellen Modus; adaptives Nachdenken verschränkt dort automatisch.

Von Partnern betriebene Plattformen ([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)) akzeptieren den Header ebenfalls auf jedem Modell, ohne einen Fehler zurückzugeben, und ignorieren ihn auf Modellen, die Interleaved Thinking nicht unterstützen.

## Turn-Struktur im manuellen Modus

Die allgemeinen Regeln zur Turn-Struktur, einschließlich der Tool-Nutzungs-Schleife innerhalb eines Turns, der Behandlung von Konflikten mitten im Turn und des Umschaltens des Nachdenkens zwischen Turns, findest du unter [Nachdenken mit Tool-Nutzung](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use).

Der manuelle Modus fügt eine Anforderung hinzu: Der letzte Assistant-Turn einer Anfrage mit aktiviertem Nachdenken muss mit einem Thinking-Block beginnen ([adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) lässt diese Anforderung fallen). Das Ändern der Denkkonfiguration zwischen Turns macht außerdem das Prompt-Caching ungültig; siehe den folgenden Abschnitt.

## Prompt-Caching im manuellen Modus

Der manuelle Modus fügt eine Regel zusätzlich zum modusneutralen Caching-Verhalten hinzu, das unter [Nachdenken und Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-prompt-caching) beschrieben ist: Das Ändern von `budget_tokens` zwischen Anfragen macht Cache-Breakpoints ungültig, genau wie das Wechseln des Denkmodus, weil der Budgetwert in den Prompt gerendert wird. Breakpoints auf Nachrichtenebene verfehlen nach einer Budgetänderung immer; ob auch Tool- und System-Prompt-Breakpoints verfehlen, hängt davon ab, wo das Modell die Konfiguration rendert.

Wähle in der Praxis ein Budget und halte es für die Lebensdauer einer gecachten Konversation stabil. Wenn du eine mehrturnige Konversation mit Caching auf Nachrichtenebene auf Claude Sonnet 4.6 ausführst und das Budget bei der dritten Anfrage von 4.000 auf 8.000 Token änderst, zeigt sich die Invalidierung direkt:

```text Output wrap
First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }
```

Die dritte Anfrage erstellt den Cache neu (`cache_creation_input_tokens=1370`, `cache_read_input_tokens=0`), weil sich das Budget zwischen den Anfragen geändert hat. Eine ausführbare Version desselben Experiments im adaptiven Modus, bei dem die Effort-Stufe die Cache-Rolle spielt, die hier `budget_tokens` spielt, findest du unter [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#prompt-caching) auf der Seite zur Steuerung des Nachdenkens.

## Gemeinsame Mechanik

Das meiste Denkverhalten ist modusneutral und einmalig auf der Seite [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking) dokumentiert. Alles dort gilt auch im manuellen Modus:

* [Steuerung der Denkanzeige](https://platform.claude.com/docs/de/build-with-claude/thinking#controlling-thinking-display)
* [Streaming des Nachdenkens](https://platform.claude.com/docs/de/build-with-claude/thinking#streaming-thinking)
* [Nachdenken mit Tool-Nutzung](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-with-tool-use), einschließlich [Beibehalten von Thinking-Blöcken](https://platform.claude.com/docs/de/build-with-claude/thinking#preserving-thinking-blocks)
* [Nachdenken und Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-prompt-caching)
* [Nachdenken und das Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-the-context-window)
* [Verschlüsselung des Nachdenkens](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-encryption)
* [Preise](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#pricing) (auf der Seite [Steuerung des Nachdenkens](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost))

## Migration zu adaptivem Nachdenken

Wenn dein Modell nur erweitertes Nachdenken unterstützt (Claude Sonnet 4.5 (abgekündigt), Claude Opus 4.5, Claude Haiku 4.5 und frühere Claude-4-Modelle), ist derzeit keine Aktion erforderlich: Adaptives Nachdenken ist dort nicht verfügbar, und `type: "adaptive"` [gibt einen 400-Fehler zurück](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#error-thinking-type-adaptive). Behalte `budget_tokens` bei, bis du zu einem Modell wechselst, das adaptives Nachdenken unterstützt, und wende dann die folgende Zuordnung an.

Du musst von `type: "enabled"` wegmigrieren, wenn:

* Du Claude Opus 4.6 oder Claude Sonnet 4.6 verwendest, bei denen `budget_tokens` abgekündigt ist.
* Du Claude 4.7 oder ein neueres Modell verwendest, etwa Claude Opus 5.5, Claude Sonnet 5, Claude Sonnet 5.5, Claude Fable 5.1 oder Claude Haiku 5.5, bei denen `type: "enabled"` einen 400-Fehler zurückgibt.

Die Zuordnung ist klein: Entferne `budget_tokens`, setze `thinking: {type: "adaptive"}` und steuere die Denktiefe mit `output_config: {effort: ...}` statt mit einem Token-Budget.

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}
```

wird zu:

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive"
  },
  "output_config": {
    "effort": "high"
  }
}
```

`effort: "high"` ist der Standard bei Claude Sonnet 4.6, daher führt das Weglassen hier zu identischem Verhalten; es erscheint nur, um zu zeigen, wo sich die Tiefensteuerung im adaptiven Modus befindet. Claude Opus 5.5 und Claude Haiku 5.5 verwenden standardmäßig `"medium"`, und andere Modelle, die Effort unterstützen, verwenden standardmäßig `"high"` (siehe [Effort-Level](https://platform.claude.com/docs/de/build-with-claude/effort#effort-levels)).

Rechne mit einem Unterschied im Verhalten, nicht nur mit einer Syntaxänderung. Mit einem festen Budget denkt Claude bei jeder Anfrage nach. Mit adaptivem Nachdenken bestimmt Claude bei jeder Anfrage, ob und wie viel es nachdenkt, und bei niedrigeren [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Einstellungen kann es das Nachdenken bei einfachen Eingaben ganz überspringen. Nach der Migration kannst du außerdem den Beta-Header `interleaved-thinking-2025-05-14` entfernen: Adaptives Nachdenken verschachtelt automatisch, und die Claude API ignoriert den Header bei diesen Modellen. Auch die Beibehaltung von Thinking-Blöcken ändert sich: Claude Opus 4.5 und Modelle mit der Nummer 4.6 und höher behalten die Thinking-Blöcke vorheriger Turns im Kontext und rechnen sie als Eingabe ab, während Claude Sonnet 4.5 (abgekündigt), Claude Haiku 4.5 und frühere Modelle sie entfernt haben; siehe [Thinking-Block-Erhaltung nach Modell](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model).

Das Wechseln des Modus ist eine Änderung der Denkkonfiguration, daher macht die erste Anfrage nach dem Wechsel Cache-Breakpoints ungültig, wie unter [Prompt-Caching im manuellen Modus](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching) beschrieben.

Vollständige Anleitungen findest du unter [adaptives Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking), [Effort](https://platform.claude.com/docs/de/build-with-claude/effort) und im [Leitfaden zur Modellmigration](https://platform.claude.com/docs/de/about-claude/models/migration-guide).

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Nachdenken" icon="brain" href="https://platform.claude.com/docs/de/build-with-claude/thinking">
    Erfahre, wie Nachdenken funktioniert: Blöcke, Anzeige, Streaming und Tool-Nutzung.
  </Card>

  <Card title="Nachdenken steuern" icon="compass" href="https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost">
    Lass Claude bei jeder Anfrage bestimmen, wann und wie viel es nachdenkt.
  </Card>

  <Card title="Nachdenken in Tool- und Multi-Turn-Workflows" icon="wrench" href="https://platform.claude.com/docs/de/build-with-claude/thinking-tool-workflows">
    Behalte Thinking-Blöcke bei und verwalte das Nachdenken über Tool-Aufrufe und Turns hinweg.
  </Card>
</CardGroup>