---
title: Effort
url: https://platform.claude.com/docs/de/build-with-claude/effort
description: Steuere mit dem effort-Parameter, wie viele Token Claude beim Antworten verwendet, und wäge dabei zwischen Gründlichkeit der Antwort und Token-Effizienz ab.
featureMetadata:
  status: ga
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements).
  supportedModels:
    - 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-opus-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-sonnet-4-6
    - claude-haiku-5-5
  supportedPlatforms:
    Claude API: ga
    Claude Platform on AWS: ga
    Amazon Bedrock: ga
    Google Cloud: ga
    Microsoft Foundry: ga
---

Mit dem „effort“-Parameter (Aufwand) kannst du steuern, wie viele Token Claude beim Beantworten von Anfragen aufwendet. Du kannst mit einem einzigen Modell zwischen Gründlichkeit der Antwort und Token-Effizienz abwägen. Der effort-Parameter auf oberster Ebene ist auf allen unterstützten Modellen verfügbar, ohne dass ein Beta-Header erforderlich ist. [Effort pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) befindet sich in der Beta-Phase.

<Tip>
  Um zu erfahren, wie Effort mit dem Nachdenken zusammenwirkt und welche Steuerung du verwenden solltest, siehe [Nachdenken und Effort](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-effort). Wo adaptives Nachdenken verfügbar ist, ist Effort der empfohlene Weg, um die Denktiefe zu steuern.
</Tip>

## Das Effort-Level festlegen

Setze `output_config.effort` in der Anfrage. Das folgende Beispiel führt eine Anfrage mit `medium`-Effort aus und gibt den Antworttext aus.

<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-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}' \
    --transform 'content.#(type=="text").text' \
    --raw-output
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  const textBlock = response.content.find(
    (block): block is Anthropic.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.messages.OutputConfig;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: 'claude-opus-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

## Wie Effort funktioniert

Die meisten Claude-Modelle verwenden standardmäßig hohen Effort und wenden so viele Token auf, wie für hervorragende Ergebnisse nötig sind; Claude Opus 5.5 und Claude Haiku 5.5 verwenden standardmäßig mittleren Effort. Du kannst das Effort-Level auf `max` erhöhen, um die absolut höchste Leistungsfähigkeit zu erhalten, oder es senken, um sparsamer mit Token umzugehen und so Geschwindigkeit und Kosten zu optimieren, wobei du eine gewisse Einbuße an Leistungsfähigkeit in Kauf nimmst.

<Tip>
  Wenn du `effort` auf den Standardwert des Modells setzt (`"medium"` bei Claude Opus 5.5 und Claude Haiku 5.5, `"high"` bei anderen Modellen), ergibt sich genau dasselbe Verhalten, als würdest du den `effort`-Parameter ganz weglassen.
</Tip>

Der Effort-Parameter wirkt sich auf **alle Token** in der Antwort aus, einschließlich:

* Textantworten und Erklärungen
* Tool-Aufrufe und Funktionsargumente
* Nachdenken (wenn aktiv)

Da Effort für jedes Ausgabe-Token gilt, funktioniert er unabhängig davon, ob Nachdenken aktiviert ist oder nicht. Niedrigerer Effort bedeutet außerdem weniger und knappere Tool-Aufrufe.

### Effort-Level

| Level    | Beschreibung                                                                                                                                                                                                                                                                                                                                             | Typischer Anwendungsfall                                                                                 |
| -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| `max`    | Absolut maximale Leistungsfähigkeit ohne Einschränkungen beim Token-Verbrauch. Verfügbar 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 Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 und Claude Haiku 5.5. | Aufgaben, die das tiefstmögliche Schlussfolgern und die gründlichste Analyse erfordern                   |
| `xhigh`  | Erweiterte Leistungsfähigkeit für Arbeit mit langem Zeithorizont. Verfügbar auf Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, 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.                                                                         | Lang laufende agentische und Coding-Aufgaben (über 30 Minuten) mit Token-Budgets in Millionenhöhe        |
| `high`   | Wendet so viele Token auf, wie die Aufgabe für hervorragende Ergebnisse benötigt. Der Standard auf jedem Modell, das Effort unterstützt, außer Claude Opus 5.5 und Claude Haiku 5.5.                                                                                                                                                                     | Komplexes Schlussfolgern, schwierige Coding-Probleme, agentische Aufgaben                                |
| `medium` | Ausgewogener Ansatz mit moderaten Token-Einsparungen. Der Standard auf Claude Opus 5.5 und Claude Haiku 5.5.                                                                                                                                                                                                                                             | Agentische Aufgaben, die ein Gleichgewicht aus Geschwindigkeit, Kosten und Leistung erfordern            |
| `low`    | Am effizientesten. Erhebliche Token-Einsparungen bei gewisser Einbuße an Leistungsfähigkeit.                                                                                                                                                                                                                                                             | Einfachere Aufgaben, die die beste Geschwindigkeit und die niedrigsten Kosten benötigen, etwa Subagenten |

Nicht jedes Modell, das `max` unterstützt, unterstützt auch `xhigh`.

<Note>
  Effort ist ein Verhaltenssignal, kein striktes Token-Budget. Bei niedrigeren Effort-Levels denkt Claude bei ausreichend schwierigen Problemen trotzdem nach, aber weniger, als es bei höheren Effort-Levels für dasselbe Problem tun würde.
</Note>

Die folgenden modellspezifischen Empfehlungen haben Vorrang vor dieser Tabelle, wo sie davon abweichen.

### Empfohlene Effort-Level für Claude Fable 5.1

Claude Fable 5.1 unterstützt alle fünf Effort-Level. **Beginne mit `high`, dem Standard.** Gehe für die leistungssensibelsten agentischen und Coding-Arbeiten auf `xhigh` oder `max` hoch und für Routine- oder latenzsensible Arbeiten auf `medium` oder `low` herunter, sobald deine Evals zeigen, dass die Qualität erhalten bleibt. Setze bei `high` und darüber ein großes `max_tokens`. Es ist ein hartes Limit für die gesamte Ausgabe (Nachdenken plus Antworttext). Dieselben Empfehlungen gelten für Claude Mythos 5.1. Siehe [Prompting für Claude Fable 5.1](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels).

Claude Fable 5.1 unterstützt außerdem das [Ändern des Efforts mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) mit einer `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt.

### Empfohlene Effort-Level für Claude Fable 5

Effort ist die primäre Steuerung, um auf Claude Fable 5 zwischen Intelligenz, Latenz und Kosten abzuwägen. **Beginne für die meisten Aufgaben mit `high`, dem Standard**, verwende `xhigh` für die leistungssensibelsten Workloads und gehe für Routinearbeiten auf `medium` oder `low` herunter. Niedrigere Effort-Einstellungen auf Claude Fable 5 liefern immer noch gute Leistung und übertreffen häufig die `xhigh`-Leistung früherer Modelle. Setze bei `high` und `xhigh` ein großes `max_tokens`. Es ist ein hartes Limit für die gesamte Ausgabe (Nachdenken plus Antworttext). Siehe [Kostenkontrolle](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#cost-control).

Reduziere den Effort, wenn eine Aufgabe zwar abgeschlossen wird, aber länger dauert als nötig, oder wenn du einen schnelleren, interaktiveren Arbeitsstil möchtest. Dieselben Empfehlungen gelten für Claude Mythos 5. Ausführlichere Hinweise findest du unter [Prompting für Claude Fable 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5).

### Empfohlene Effort-Level für Claude Opus 5.5

Claude Opus 5.5 unterstützt alle fünf Effort-Level, und `medium` ist der Standard (Claude Opus 5 und frühere Opus-Modelle verwenden standardmäßig `high`, sodass eine Anfrage, die `effort` weglässt, eine Stufe niedriger läuft als bei Claude Opus 5). Adaptives Nachdenken ist immer aktiv und kann nicht deaktiviert werden, daher ist Effort die primäre Steuerung dafür, wie viel das Modell nachdenkt und was eine Anfrage kostet. Führe einen Effort-Sweep mit deinen eigenen Evals durch, anstatt Einstellungen von einem früheren Modell zu übernehmen, und setze bei den höheren Levels einen großen Wert für `max_tokens`: Er ist eine harte Obergrenze für die gesamte Ausgabe (Nachdenken plus Antworttext). Anfragen, die `thinking: {"type": "disabled"}` setzen, geben auf jedem Effort-Level einen 400-Fehler zurück. Claude Opus 5.5 unterstützt außerdem das [Ändern des Efforts mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) mit einer `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt. Siehe [Prompting für Claude Opus 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).

### Empfohlene Effort-Level für Claude Opus 5

Claude Opus 5 unterstützt alle fünf Effort-Level. **Beginne mit `high`, dem Standard**, und passe ihn anhand deiner Evals an: Wechsle zu `xhigh` für anspruchsvolle Coding- und agentische Arbeit oder zu `max`, wenn eine Aufgabe uneingeschränkten Token-Verbrauch rechtfertigt, und verwende `low` und `medium` großzügig als deine wichtigste Steuerung für Token-Kosten und Antwortzeit, wo immer deine Evals zeigen, dass die Qualität erhalten bleibt. Wenn du Effort-Einstellungen von einem früheren Modell übernommen hast, führe einen neuen Effort-Sweep mit deinen Evals durch, anstatt sie wiederzuverwenden.

Effort steuert den Umfang des Nachdenkens, nicht die Länge der sichtbaren Antwort: Bei Claude Opus 5 verkürzt eine Änderung des Efforts die Antworten nicht zuverlässig, daher solltest du stattdessen [die Länge per Prompt vorgeben](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity).

Der API-Standard ist `high`. Setze `effort` explizit, um ein anderes Level zu verwenden. Der übergebene Wert überschreibt den Standard.

Bei Claude Opus 5 kann das Nachdenken bei Effort `xhigh` oder `max` nicht deaktiviert werden: Anfragen, die auf diesen Levels `thinking: {"type": "disabled"}` setzen, geben einen 400-Fehler zurück. Siehe [Effort mit Nachdenken](https://platform.claude.com/docs/de/build-with-claude/effort#effort-with-thinking).

Wenn du Claude Opus 5 mit Effort `xhigh` oder `max` ausführst, setze einen großen Wert für `max_tokens`, damit das Modell genug Spielraum hat, um über Subagenten und Tool-Aufrufe hinweg nachzudenken und zu handeln. Mit 64k Token zu beginnen und von dort aus nachzujustieren, ist ein sinnvoller Standard.

Claude Opus 5 unterstützt außerdem das [Ändern des Efforts mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) mit einer `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt. Effort pro Nachricht ist für Claude Opus 5 auf Amazon Bedrock nicht verfügbar.

### Empfohlene Effort-Level für Claude Opus 4.8

Die Hinweise für Claude Opus 4.7 gelten auch für Claude Opus 4.8. **Beginne mit `xhigh` für Coding- und agentische Anwendungsfälle**, verwende `high` für die meisten anderen intelligenzsensiblen Workloads und gehe nur dann auf `medium` oder `low` herunter, wenn du gemessen hast, dass das niedrigere Level die Qualität auf deinen Evals hält.

Der API-Standard ist `high`. Setze `effort` explizit, um ein anderes Level zu verwenden. Der übergebene Wert überschreibt den Standard.

Wenn du Claude Opus 4.8 mit `xhigh`- oder `max`-Effort betreibst, setze ein großes `max_tokens`, damit das Modell Raum hat, über Subagenten und Tool-Aufrufe hinweg zu denken und zu handeln. Mit 64k Token zu beginnen und von dort aus abzustimmen, ist ein vernünftiger Standard.

### Empfohlene Effort-Level für Claude Opus 4.7

**Beginne für Coding- und agentische Anwendungsfälle mit `xhigh`** und verwende `high` als Minimum für die meisten intelligenzkritischen Workloads. Gehe für kostensensible Workloads auf `medium` herunter oder nur dann auf `max` hoch, wenn deine Evals messbaren Spielraum bei `xhigh` zeigen.

Der API-Standard ist `high`. Um `xhigh` zu verwenden, setze `effort` explizit. Der übergebene Wert überschreibt den Standard.

| Effort   | Hinweise für Claude Opus 4.7                                                                                                                                                                                                                                                                   |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `low`    | Effizient, aber am besten für kurze, klar abgegrenzte Aufgaben. Kombiniere `low` mit expliziten Checklisten, wenn deine Aufgabe mehrere Abschnitte hat.                                                                                                                                        |
| `medium` | Der direkte Ersatz für den durchschnittlichen Workflow, bei dem du gute Ergebnisse bei geringeren Kosten möchtest.                                                                                                                                                                             |
| `high`   | Fortgeschrittene Anwendungsfälle, die dennoch ein Gleichgewicht zwischen Intelligenz und Token-Verbrauch benötigen. Dies ist oft das beste Gleichgewicht zwischen Qualität und Token-Effizienz.                                                                                                |
| `xhigh`  | Der empfohlene Ausgangspunkt für Coding- und agentische Arbeit sowie für explorative Aufgaben wie wiederholte Tool-Aufrufe, detaillierte Websuche und Wissensdatenbanksuche. Rechne mit deutlich höherem Token-Verbrauch als bei `high`.                                                       |
| `max`    | Reserviere es für Probleme an der Leistungsgrenze. Bei den meisten Workloads verursacht `max` erhebliche Mehrkosten für relativ geringe Qualitätsgewinne, und bei manchen Aufgaben mit strukturierter Ausgabe oder geringerer Intelligenzanforderung kann es zu übermäßigem Nachdenken führen. |

Claude Opus 4.7 hält sich außerdem strenger an Effort-Level als Claude Opus 4.6, insbesondere bei `low` und `medium`. Bei niedrigeren Effort-Levels beschränkt das Modell seine Arbeit auf das, was verlangt wurde, anstatt mehr als angefordert zu tun. Wenn du bei Claude Opus 4.7 oberflächliches Schlussfolgern bei komplexen Problemen beobachtest, erhöhe den Effort, anstatt das Problem per Prompt zu umgehen. Wenn du den Effort aus Latenzgründen niedrig halten musst, füge gezielte Hinweise hinzu wie „Diese Aufgabe erfordert mehrstufiges Schlussfolgern. Denke sorgfältig nach, bevor du antwortest.“

Wenn du Claude Opus 4.7 mit Effort `xhigh` oder `max` ausführst, setze einen großen Wert für `max_tokens`, damit das Modell genug Spielraum hat, um über Subagenten und Tool-Aufrufe hinweg nachzudenken und zu handeln. Mit 64k Token zu beginnen und von dort aus nachzujustieren, ist ein sinnvoller Standard.

### Empfohlene Effort-Level für Claude Sonnet 5.5

Claude Sonnet 5.5 unterstützt alle fünf Effort-Level, und `high` ist der Standard in der Claude API. Seine Level sind neu kalibriert, sodass ein Level nicht dieselbe Menge an Nachdenken erzeugt wie dasselbe Level bei Claude Sonnet 5. Führe einen neuen Effort-Sweep mit deinen Evals durch, anstatt die Einstellung zu übernehmen, die du bei Claude Sonnet 5 verwendet hast. Beginne mit `high`, es sei denn, dein Workload ist agentisch oder latenzkritisch. Für agentisches Coding und mehrstufige Tool-Nutzung beginne bei klar spezifizierten Aufgaben mit `medium` und wechsle bei schwierigeren oder längeren Aufgaben zu `high`. Für Chat und andere latenzkritische Arbeit beginne mit `medium` oder `low`. Verwende `xhigh` oder `max` nur dort, wo deine Evals einen Qualitätsgewinn zeigen. Setze `max_tokens` mit genug Spielraum für Nachdenken und Antwort. Nachdenken zählt zu `max_tokens`, auch wenn der Inhalt des Nachdenkens nicht zurückgegeben wird. Für agentisches Coding setze `max_tokens` auf 128.000, das Maximum des Modells, und verwende [Streaming](https://platform.claude.com/docs/de/build-with-claude/streaming) für die Antwort.

Um das vorgelagerte Nachdenken auszuschalten, sende `thinking: {"type": "between_tools"}` statt `"disabled"`. Das ist die niedrigste Nachdenk-Einstellung bei Claude Sonnet 5.5, und sie funktioniert bei Effort `low`, `medium` und `high`. Bei `xhigh` oder `max` gibt eine Anfrage damit einen 400-Fehler zurück, verwende auf diesen Levels daher adaptives Nachdenken: Lass das Feld `thinking` weg oder sende `thinking: {"type": "adaptive"}`. 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).

Claude Sonnet 5.5 unterstützt außerdem das [Ändern des Efforts mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) mit einer `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt. Mit `between_tools` kann sich der Effort nicht mitten im Gespräch ändern: Ein `output_config.effort` pro Nachricht, das vom aktuell geltenden Level abweicht, gibt einen 400-Fehler zurück. Um den Effort pro Turn zu variieren, verwende adaptives Nachdenken. Siehe [Prompting für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort).

### Empfohlene Effort-Level für Claude Sonnet 5

Claude Sonnet 5 verwendet auf der Claude API und in Claude Code standardmäßig `high`-Effort.

* **High-Effort (Standard):** Geeignet für komplexes Schlussfolgern, Coding und agentische Aufgaben, bei denen Qualität wichtiger ist als Geschwindigkeit oder Kosten.
* **Xhigh-Effort:** Für die schwierigsten Coding- und agentischen Aufgaben. Siehe [Prompting für Claude Sonnet 5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5#calibrating-effort-and-thinking-depth).
* **Medium-Effort:** Kostensparende Stufe unterhalb des Standards. Vergleichbar mit Claude Sonnet 4.6 bei High-Effort.
* **Low-Effort:** Für Workloads mit hohem Volumen oder Latenzsensibilität. Geeignet für Chat- und Nicht-Coding-Anwendungsfälle, bei denen schnellere Bearbeitung Priorität hat.
* **Max-Effort:** Für Aufgaben, die die absolut höchste Leistungsfähigkeit ohne Einschränkungen beim Token-Verbrauch erfordern.

### Empfohlene Effort-Level für Claude Sonnet 4.6

Sonnet 4.6 verwendet standardmäßig Effort `high`. Setze den Effort bei der Verwendung von Sonnet 4.6 explizit, um unerwartete Latenz zu vermeiden:

* **Medium-Effort** (empfohlener Standard): Bestes Gleichgewicht aus Geschwindigkeit, Kosten und Leistung für die meisten Anwendungen. Geeignet für agentisches Coding, Tool-intensive Workflows und Codegenerierung.
* **Low-Effort:** Für Workloads mit hohem Volumen oder Latenzsensibilität. Geeignet für Chat- und Nicht-Coding-Anwendungsfälle, bei denen schnellere Bearbeitung Priorität hat.
* **High-Effort:** Für komplexes Schlussfolgern und Aufgaben, bei denen Qualität wichtiger ist als Geschwindigkeit oder Kosten.
* **Max-Effort:** Für Aufgaben, die die absolut höchste Leistungsfähigkeit ohne Einschränkungen beim Token-Verbrauch erfordern.

### Empfohlene Effort-Level für Claude Haiku 5.5

Claude Haiku 5.5 unterstützt alle fünf Effort-Level, und `medium` ist der Standard. Effort ist die wichtigste Steuerung dafür, wie viel das Modell nachdenkt, und damit für Qualität, Latenz und Kosten. **Beginne für die meisten Arbeiten mit `medium`**, einschließlich agentischem Coding. Verwende `low`, das günstigste und schnellste Level, für Chat, kurze Tool-Aufgaben und einfache Anfragen mit hohem Volumen. Bei langen Agenten-Prompts ist es bei `low` wahrscheinlicher, dass das Modell eine Suche auslässt, früh aufhört oder eine Prüfung überspringt. Verwende `high` für Wissensarbeit, längere Agentenaufgaben und striktes Befolgen von Anweisungen. Verwende `xhigh` oder `max` nur dort, wo deine Evals einen Qualitätsgewinn zeigen, und vergleiche sie hinsichtlich Leistung, Kosten und Geschwindigkeit mit Claude Sonnet 5.5. Nachdenken ist standardmäßig aktiv und zählt zu `max_tokens`, lass also Spielraum dafür. Siehe [Prompting für Claude Haiku 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).

Um weniger Nachdenken zu erhalten, senke das Effort-Level. Du kannst bei Effort `high` oder darunter auch `thinking: {"type": "disabled"}` senden. Bei `xhigh` oder `max` gibt dies einen 400-Fehler zurück, verwende dort daher adaptives Nachdenken: Lass das Feld `thinking` weg oder sende `thinking: {"type": "adaptive"}`.

In der Claude API und auf Google Cloud unterstützt Claude Haiku 5.5 außerdem das [Ändern des Efforts mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) mit einer `output_config` pro Nachricht, wodurch der Prompt-Cache erhalten bleibt. Mit `thinking: {"type": "disabled"}` kann sich der Effort nicht mitten im Gespräch ändern: Ein `output_config.effort` pro Nachricht, das vom aktuell geltenden Level abweicht, gibt einen 400-Fehler zurück. Um den Effort pro Turn zu variieren, verwende adaptives Nachdenken.

## Effort mit Tool-Nutzung

Bei der „tool use“ (Tool-Nutzung) wirkt sich der effort-Parameter sowohl auf die Erklärungen rund um Tool-Aufrufe als auch auf die Tool-Aufrufe selbst aus. Niedrigere Effort-Level neigen dazu:

* Mehrere Operationen in weniger Tool-Aufrufen zusammenzufassen
* Weniger Tool-Aufrufe zu machen
* Ohne Vorrede direkt zur Aktion überzugehen
* Nach Abschluss knappe Bestätigungsnachrichten zu verwenden

Höhere Effort-Level können:

* Mehr Tool-Aufrufe machen
* Den Plan erklären, bevor sie handeln
* Detaillierte Zusammenfassungen der Änderungen liefern
* Umfassendere Code-Kommentare einfügen

## Effort mit Nachdenken

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.

Bei höheren Effort-Stufen denkt Claude bereitwilliger und ausführlicher nach. In einer Tool-Nutzungs-Schleife können Folgeanfragen, die nur Tool-Ergebnisse verarbeiten, das Nachdenken auf jeder Stufe trotzdem überspringen. Bei niedrigeren Stufen kann Claude das Nachdenken bei einfacheren Problemen ganz überspringen. Ausführliche Hinweise dazu, wie die beiden Steuerungen zusammenwirken, findest du unter [Nachdenken und Effort](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-effort).

Auf Claude Opus 4.5, dem einzigen Modell mit ausschließlich erweitertem Nachdenken, das Effort unterstützt, arbeitet er zusammen mit [`budget_tokens`](https://platform.claude.com/docs/de/build-with-claude/extended-thinking): Setze das Effort-Level für deine Aufgabe und lege dann das Token-Budget für das Nachdenken danach fest, wie viel Denktiefe die Aufgabe benötigt.

Zur Verfügbarkeit des Nachdenkens pro Modell siehe die [Konfigurationstabelle pro Modell](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#supported-models). Effort funktioniert mit oder ohne Nachdenken. Siehe [Wie Effort funktioniert](https://platform.claude.com/docs/de/build-with-claude/effort#how-effort-works).

## Effort mitten im Gespräch ändern

Du kannst spätere Turns eines Gesprächs auf zwei Arten mit einem anderen Effort-Level ausführen. Bei Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 und Claude Haiku 5.5 verwendest du eine Effort-Änderung pro Nachricht, wodurch der Prompt-Cache erhalten bleibt. Bei anderen Modellen setzt du in der nächsten Anfrage einen neuen Wert auf oberster Ebene, wodurch der Cache neu beginnt.

### Effort pro Nachricht (Beta)

Effort pro Nachricht befindet sich in der Beta-Phase. In der Claude API und auf [Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-on-vertex-ai) ist er auf Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 und Claude Haiku 5.5 verfügbar. Auf [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) ist er auf Claude Fable 5.1, Claude Mythos 5.1 und Claude Opus 5.5 verfügbar. Er erfordert den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `mid-conversation-output-config-2026-07-01`. Mit der Amazon Bedrock [InvokeModel API](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) ist er auf Claude Fable 5.1 und Claude Opus 5.5 verfügbar, und du sendest diesen Wert stattdessen im Array `anthropic_beta` des Request-Bodys.

Ohne den Beta-Wert gibt eine `output_config` pro Nachricht einen 400-Fehler zurück: `messages.N.output_config: Extra inputs are not permitted`, wobei `N` der Index der `system`-Nachricht in `messages` ist. Mit dem Beta-Wert geben Modelle ohne Effort pro Nachricht, einschließlich Claude Fable 5, einen 400-Fehler zurück: `output_config.effort requires a model that supports per-turn effort; this model does not`. Auf Amazon Bedrock geben diese Modelle und Claude Opus 5 stattdessen den Fehler `Extra inputs are not permitted` zurück. Bei Claude Sonnet 5.5 mit `thinking: {"type": "between_tools"}` und bei Claude Haiku 5.5 mit `thinking: {"type": "disabled"}` kann sich der Effort nicht mitten im Gespräch ändern: Ein `output_config.effort` pro Nachricht, das vom aktuell geltenden Level abweicht, gibt einen 400-Fehler zurück. Um den Effort pro Turn zu variieren, verwende adaptives Nachdenken.

Füge eine Nachricht mit `role: "system"`, leerem `content` und dem neuen Level in `output_config.effort` hinzu. Direkt nach einem `user`-Turn mit neuer Eingabe platziert, legt sie das Level für Claudes Antwort auf diesen Turn fest. An jeder anderen Stelle platziert, etwa zwischen einem `assistant`-Turn und dem nächsten `user`-Turn wie im folgenden Beispiel, wird sie ab dem nächsten `user`-Turn mit neuer Eingabe wirksam. Ein `user`-Turn, der nur `tool_result`-Blöcke enthält, zählt nicht als neue Eingabe, sodass eine danach platzierte Änderung in einer Tool-Nutzungs-Schleife auf den nächsten `user`-Turn mit neuer Eingabe wartet. Das neue Level gilt dann, bis eine spätere Nachricht es ändert. Alles vor dieser Nachricht bleibt unverändert, sodass das gecachte Präfix weiterhin übereinstimmt.

Das folgende Beispiel beginnt mit `high` und wechselt dann für eine routinemäßige Folgefrage zu `low`:

<CodeGroup>
  ```bash cURL
  # Reine Effort-Systemnachricht: Die neue Stufe gilt ab dem nächsten User-Turn.
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: mid-conversation-output-config-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-fable-5-1",
      "max_tokens": 4096,
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."}
      ]
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta mid-conversation-output-config-2026-07-01 \
    --transform 'content.#(type=="text").text' --raw-output <<'YAML'
  model: claude-fable-5-1
  max_tokens: 4096
  output_config:
    effort: high
  messages:
    - role: user
      content: Plan a migration from SQLite to PostgreSQL in three short steps.
    - role: assistant
      content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    # Reine Effort-Systemnachricht: Die neue Stufe gilt ab dem nächsten User-Turn.
    - role: system
      content: []
      output_config:
        effort: low
    - role: user
      content: Summarize the plan in one sentence.
  YAML
  ```

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

  response = client.beta.messages.create(
      model="claude-fable-5-1",
      max_tokens=4096,
      output_config={"effort": "high"},
      messages=[
          {
              "role": "user",
              "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
          },
          {
              "role": "assistant",
              "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
          },
          # Reine Effort-Systemnachricht: Die neue Stufe gilt ab dem nächsten User-Turn.
          {"role": "system", "content": [], "output_config": {"effort": "low"}},
          {"role": "user", "content": "Summarize the plan in one sentence."},
      ],
      betas=["mid-conversation-output-config-2026-07-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

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

  const response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: { effort: "high" },
    messages: [
      {
        role: "user",
        content: "Plan a migration from SQLite to PostgreSQL in three short steps."
      },
      {
        role: "assistant",
        content:
          "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
      },
      // Systemnachricht nur für Effort: Die neue Stufe gilt ab dem nächsten User-Turn.
      { role: "system", content: [], output_config: { effort: "low" } },
      { role: "user", content: "Summarize the plan in one sentence." }
    ],
    betas: ["mid-conversation-output-config-2026-07-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  ```

  ```csharp C#
  using Anthropic.Models.Beta;
  using Anthropic.Models.Beta.Messages;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeFable5_1,
      MaxTokens = 4096,
      OutputConfig = new() { Effort = Effort.High },
      Messages =
      [
          new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
          new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
          // Systemnachricht nur für Effort: Die neue Stufe gilt ab dem nächsten Benutzer-Turn.
          new()
          {
              Role = Role.System,
              Content = new([]),
              OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
          },
          new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
      ],
      Betas = [AnthropicBeta.MidConversationOutputConfig2026_07_01],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

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

  response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeFable5_1,
  	MaxTokens: 4096,
  	OutputConfig: anthropic.BetaOutputConfigParam{
  		Effort: anthropic.BetaOutputConfigEffortHigh,
  	},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
  		{
  			Role:    anthropic.BetaMessageParamRoleAssistant,
  			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
  		},
  		// Systemnachricht nur für Effort: Die neue Stufe gilt ab dem nächsten User-Turn.
  		anthropic.NewBetaSystemMessage(anthropic.BetaSystemMessageOutputConfigParam{
  			Effort: anthropic.BetaSystemMessageOutputConfigEffortLow,
  		}),
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize the plan in one sentence.")),
  	},
  	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationOutputConfig2026_07_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.models.beta.AnthropicBeta;
  import com.anthropic.models.beta.messages.BetaMessage;
  import com.anthropic.models.beta.messages.BetaMessageParam;
  import com.anthropic.models.beta.messages.BetaOutputConfig;
  import com.anthropic.models.beta.messages.BetaSystemMessageOutputConfig;
  import com.anthropic.models.beta.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_FABLE_5_1)
          .maxTokens(4096L)
          .addBeta(AnthropicBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
          .outputConfig(BetaOutputConfig.builder()
              .effort(BetaOutputConfig.Effort.HIGH)
              .build())
          .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
          .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
          // Systemnachricht nur für Effort: Die neue Stufe gilt ab dem nächsten User-Turn.
          .addMessage(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.SYSTEM)
              .contentOfBetaContentBlockParams(List.of())
              .outputConfig(BetaSystemMessageOutputConfig.builder()
                  .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                  .build())
              .build())
          .addUserMessage("Summarize the plan in one sentence.")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Beta\AnthropicBeta;
  use Anthropic\Beta\Messages\BetaMessageParam;
  use Anthropic\Beta\Messages\BetaOutputConfig;
  use Anthropic\Beta\Messages\BetaSystemMessageOutputConfig;
  use Anthropic\Client;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: 'claude-fable-5-1',
      maxTokens: 4096,
      outputConfig: BetaOutputConfig::with(effort: 'high'),
      messages: [
          BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
          BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
          // System-Nachricht nur für Effort: Die neue Stufe gilt ab dem nächsten User-Turn.
          BetaMessageParam::with(
              role: 'system',
              content: [],
              outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
          ),
          BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
      ],
      betas: [AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
  );

  foreach ($response->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }
  ```

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

  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 4096,
    output_config: {effort: :high},
    messages: [
      {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
      {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
      # Reine Effort-Systemnachricht: Die neue Stufe gilt ab dem nächsten User-Turn.
      {role: "system", content: [], output_config: {effort: :low}},
      {role: "user", content: "Summarize the plan in one sentence."}
    ],
    betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
  )

  response.content.each do |block|
    puts block.text if block.type == :text
  end
  ```
</CodeGroup>

Eine System-Nachricht, die nur den Effort festlegt, enthält keinen Text, daher gelten die [Platzierungsregeln für System-Nachrichten mitten im Gespräch](https://platform.claude.com/docs/de/build-with-claude/mid-conversation-system-messages#limitations) nicht. Sie kann an beliebiger Stelle in `messages` stehen, auch als erster Eintrag oder zwischen einem `assistant`-Turn und dem nächsten `user`-Turn. Die Werte sind die Level-Namen (`low`, `medium`, `high`, `xhigh` und `max`).

Bevorzuge diese Form gegenüber dem Ändern des Werts auf oberster Ebene zwischen Anfragen. Eine Änderung auf oberster Ebene startet den Cache neu und steuert bei Claude Fable 5.1 das Modell außerdem weniger zuverlässig: Seine früheren Antworten wurden auf dem vorherigen Level geschrieben, und es neigt dazu, mit ihnen konsistent zu bleiben.

### Effort auf oberster Ebene in der nächsten Anfrage

Das `output_config.effort` auf oberster Ebene gilt für die gesamte Anfrage. Um einen späteren Teil eines Gesprächs auf einem anderen Level auszuführen, setze den neuen Wert in der nächsten Anfrage. Da Effort auf oberster Ebene den gerenderten Prompt formt, bleiben gecachte Präfixe aus früheren Turns bei einer Änderung zwischen Anfragen nicht erhalten. Wenn du dich über eine lange Sitzung hinweg auf „prompt caching“ (Prompt-Caching) verlässt, siehe [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching), und dein Modell Effort pro Nachricht nicht unterstützt, wähle zu Beginn ein Effort-Level und halte es konstant.

## Best Practices

1. **Setze den Effort explizit:** Die API verwendet standardmäßig `high` (`medium` bei Claude Opus 5.5 und Claude Haiku 5.5), aber der richtige Ausgangspunkt hängt von deinem Modell und deinem Workload ab.
2. **Verwende low für geschwindigkeitskritische oder einfache Aufgaben:** Wenn Latenz wichtig ist oder Aufgaben unkompliziert sind, kann niedriger Effort Antwortzeiten und Kosten erheblich reduzieren.
3. **Teste deinen Anwendungsfall:** Die Auswirkung der Effort-Level variiert je nach Aufgabentyp. Bewerte die Leistung bei deinen spezifischen Anwendungsfällen, bevor du sie bereitstellst.
4. **Erwäge dynamischen Effort:** Passe den Effort an die Komplexität der Aufgabe an. Einfache Anfragen rechtfertigen möglicherweise niedrigen Effort, während agentisches Coding und komplexes Schlussfolgern von hohem Effort profitieren. Lies den nächsten Punkt, bevor du ihn innerhalb eines Gesprächs variierst.
5. **Halte den Effort auf oberster Ebene in gecachten Gesprächen konstant:** Eine Änderung des Effort-Werts auf oberster Ebene zwischen Anfragen macht das [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) ungültig, variiere ihn daher zwischen Workloads statt innerhalb eines Gesprächs, die auf Cache-Treffer angewiesen ist. Verwende bei Modellen, die dies unterstützen, stattdessen eine [Effort-Änderung pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta), wodurch der Cache erhalten bleibt. Siehe [Nachdenken und Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-prompt-caching).

## Nächste Schritte

<CardGroup>
  <Card title="Aufgabenbudgets" icon="gauge" href="https://platform.claude.com/docs/de/build-with-claude/task-budgets">
    Gib Claude ein unverbindliches Token-Budget für die gesamte agentische Schleife, damit sich das Modell bei langen agentischen Aufgaben selbst regulieren kann.
  </Card>

  <Card title="Nachdenken steuern" icon="compass" href="https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost">
    Verstehe adaptives Nachdenken, bei dem Claude bestimmt, wann und wie viel es nachdenkt, und steuere es mit Effort und Prompting.
  </Card>

  <Card title="Nachdenken" icon="brain" href="https://platform.claude.com/docs/de/build-with-claude/thinking">
    Verstehe, wie Nachdenken funktioniert, wann Claude standardmäßig nachdenkt und wie Nachdenken mit Effort zusammenwirkt.
  </Card>
</CardGroup>