---
title: Réflexion étendue
url: https://platform.claude.com/docs/fr/build-with-claude/extended-thinking
description: Configurez la réflexion étendue manuelle avec un budget budget_tokens fixe sur les modèles Claude qui la prennent en charge, et migrez vers la réflexion adaptative.
---

<Note>
  Pour savoir comment la « zero data retention » (rétention zéro des données), ou ZDR, s'applique à cette fonctionnalité, consultez [API et rétention des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
</Note>

<Warning>
  L'« extended thinking » (réflexion étendue) (`thinking.type: "enabled"` avec `budget_tokens`) est dépréciée sur les modèles Claude 4.6 (les requêtes qui l'utilisent aboutissent toujours). Les modèles Claude 4.7 et ultérieurs ne la prennent pas en charge et rejettent les requêtes qui l'utilisent, en renvoyant une erreur 400. Sur les modèles Claude 4.5 et antérieurs qui prennent en charge la réflexion, la réflexion étendue est le seul mode de réflexion disponible. Claude Mythos Preview prend en charge les deux modes. Lorsque les deux modes sont disponibles, utilisez plutôt l'[adaptive thinking](https://platform.claude.com/docs/fr/build-with-claude/thinking) (réflexion adaptative).

  Consultez [Migrer vers la réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#migrating-to-adaptive-thinking) pour passer à la réflexion adaptative. Si votre modèle ne prend en charge que la réflexion étendue, cette page décrit la configuration prise en charge ; aucun changement n'est nécessaire tant que vous ne passez pas à un modèle plus récent.
</Warning>

<Note>
  Si une requête échoue avec une erreur 400 dont le message commence par `"thinking.type.enabled" is not supported`, votre modèle utilise la réflexion adaptative à la place. Consultez [Dépannage de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking-troubleshooting#error-thinking-type-enabled), ou passez directement à [Migrer vers la réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).
</Note>

L'« extended thinking » (réflexion étendue) en mode manuel vous donne un contrôle direct sur la quantité de réflexion de Claude. Vous définissez un budget de tokens de réflexion sur chaque requête avec `thinking: {type: "enabled", budget_tokens: N}`, et Claude réfléchit dans la limite de ce budget avant de commencer sa réponse finale. Le mode manuel reste utile lorsque votre charge de travail exige une latence prévisible ou un contrôle précis des coûts de réflexion. Cette page explique comment définir et ajuster le budget, comment le mode manuel interagit avec la réflexion entrelacée et la « prompt caching » (mise en cache des prompts), et comment migrer vers la réflexion adaptative.

Pour comprendre le fonctionnement de la réflexion elle-même, y compris les blocs de réflexion et la forme de la réponse, le paramètre `display`, le streaming, la réflexion avec l'« tool use » (utilisation d'outils) et le chiffrement, consultez la [présentation de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking).

## Modèles pris en charge

La disponibilité de la réflexion étendue par modèle, y compris les modèles pour lesquels la réflexion étendue est le seul mode, est indiquée dans le [tableau de configuration par modèle](https://platform.claude.com/docs/fr/build-with-claude/thinking-troubleshooting#supported-models).

## Comment utiliser la réflexion étendue

Voici un exemple d'utilisation de la réflexion étendue dans l'API Messages :

<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?",
          }
      ],
  )

  # La réponse contient des blocs de réflexion résumés et des blocs de texte
  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?"
      }
    ]
  });

  // La réponse contient des blocs de réflexion résumés et des blocs de texte
  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?",
          },
      ],
  });

  // La réponse contient des blocs de réflexion résumés et des blocs de texte
  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)
  }

  // La réponse contient des blocs de réflexion résumés et des blocs de texte
  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);

      // La réponse contient des blocs de réflexion résumés et des blocs de texte
      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?',
          ],
      ],
  );

  // La réponse contient des blocs de réflexion résumés et des blocs de texte
  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?"
      }
    ]
  )

  # La réponse contient des blocs de réflexion résumés et des blocs de texte
  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>

Pour activer la réflexion étendue manuelle, ajoutez un objet `thinking` avec `type` défini sur `enabled` et une valeur `budget_tokens`.

Le paramètre `budget_tokens` définit une cible pour le nombre de tokens que Claude peut utiliser pour son processus de raisonnement interne. Des budgets plus importants peuvent améliorer la qualité des réponses en permettant une analyse plus approfondie des problèmes complexes.

## Règles et ajustement du budget

`budget_tokens` doit respecter ces contraintes :

* **Minimum de 1 024 tokens.** L'API rejette les valeurs inférieures.
* **Inférieur à `max_tokens`.** Les tokens de réflexion sont comptabilisés dans la limite `max_tokens` du tour, le budget doit donc laisser de la place pour la réponse finale. La seule exception est la [réflexion entrelacée](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#interleaved-thinking), où `budget_tokens` peut dépasser `max_tokens` car le budget couvre tous les blocs de réflexion au sein d'un même tour de l'assistant.
* **Pas de préchauffage du cache.** Comme `budget_tokens` doit être inférieur à `max_tokens`, la réflexion étendue ne peut pas être combinée avec `max_tokens: 0` ([préchauffage du cache](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#pre-warming-the-cache)).

Le budget est une cible plutôt qu'un plafond strict. L'utilisation réelle de tokens varie selon la tâche, et Claude peut arrêter de raisonner bien avant que le budget ne soit épuisé ; `max_tokens` reste le plafond absolu de la sortie totale.

Sur Claude Opus 4.5, le seul modèle limité à la réflexion étendue qui prend en charge l'[effort](https://platform.claude.com/docs/fr/build-with-claude/effort), l'effort façonne la réponse globale tandis que `budget_tokens` définit la profondeur de réflexion ; définissez les deux.

Pour ajuster le budget :

* Adaptez le point de départ à la tâche. Pour les tâches simples, commencez près du minimum de 1 024 tokens et augmentez progressivement pour trouver la plage optimale pour votre cas d'usage. Pour les tâches complexes, commencez avec un budget plus important de 16 000 tokens ou plus et ajustez selon vos besoins en matière de latence et de qualité. Des budgets plus élevés permettent un raisonnement plus complet, avec des rendements décroissants qui dépendent de la tâche, et au prix d'une latence accrue. Pour les tâches critiques, testez différents réglages pour trouver le bon équilibre.
* Pour les budgets de réflexion supérieurs à 32k, utilisez le [traitement par lots](https://platform.claude.com/docs/fr/build-with-claude/batch-processing) pour éviter les problèmes réseau. Pousser le modèle à réfléchir au-delà de 32k tokens produit des requêtes de longue durée qui peuvent atteindre les délais d'expiration du système et les limites de connexions ouvertes.

Pour suivre ce qu'un budget vous coûte réellement, surveillez le champ `usage.output_tokens_details.thinking_tokens` dans la réponse, qui indique combien des tokens de sortie facturés correspondaient au raisonnement interne. En streaming, cette ventilation n'apparaît que dans l'événement final `message_delta`.

Lorsque vous êtes prêt à abandonner les budgets manuels, consultez [Migrer vers la réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).

## Réflexion entrelacée en mode manuel

L'« interleaved thinking » (réflexion entrelacée) permet à Claude de réfléchir entre les appels d'outils au sein d'un même tour de l'assistant, en raisonnant sur chaque résultat d'outil avant de déterminer la suite. Pour le concept, la structure des tours et son comportement sur les modèles à réflexion adaptative, consultez la section [réflexion entrelacée](https://platform.claude.com/docs/fr/build-with-claude/thinking#interleaved-thinking) de la présentation de la réflexion. Cette section explique comment l'activer lorsque vous utilisez la réflexion manuelle `type: "enabled"`.

Sur Claude Opus 4.5, Claude Sonnet 4.5 (déprécié) et les modèles Claude 4 antérieurs, ajoutez l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `interleaved-thinking-2025-05-14` à votre requête API.

La génération 4.6 se divise en mode manuel :

* **Claude Sonnet 4.6** : l'en-tête bêta avec le mode manuel `type: "enabled"` est toujours fonctionnel mais déprécié. Préférez la [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking), qui entrelace automatiquement sans en-tête.
* **Claude Opus 4.6** : le mode manuel ne dispose d'aucune réflexion entrelacée. Seul son mode adaptatif entrelace, passez donc à `thinking: {type: "adaptive"}` si vous avez besoin de raisonnement entre les appels d'outils sur ce modèle.

Claude Haiku 4.5 ne prend pas en charge la réflexion entrelacée. Sur l'API Claude, l'en-tête bêta est accepté mais ignoré.

Deux considérations supplémentaires pour la réflexion entrelacée en mode manuel :

* `budget_tokens` peut ici dépasser `max_tokens` ; les [règles du budget](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#budget-rules-and-tuning) expliquent cette exception.
* La réflexion entrelacée n'est prise en charge que pour les [outils utilisés via l'API Messages](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview).

Le traitement de l'en-tête bêta diffère selon les plateformes. L'API Claude et [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) acceptent `interleaved-thinking-2025-05-14` sur n'importe quel modèle et l'ignorent là où il n'est pas pris en charge. L'acceptation n'équivaut pas à un effet : sur les modèles qui rejettent `type: "enabled"` (4.7 et ultérieurs) ou qui ne disposent pas de l'entrelacement en mode manuel (Claude Opus 4.6), l'en-tête n'a aucun effet en mode manuel ; la réflexion adaptative y entrelace automatiquement.

Les plateformes exploitées par des partenaires ([Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) et [Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai)) acceptent également l'en-tête sur n'importe quel modèle sans renvoyer d'erreur, et l'ignorent sur les modèles qui ne prennent pas en charge la réflexion entrelacée.

## Structure des tours en mode manuel

Les règles générales de structure des tours, y compris la boucle d'utilisation d'outils sur un seul tour, la gestion des conflits en milieu de tour et l'activation ou la désactivation de la réflexion entre les tours, se trouvent dans [Réflexion avec utilisation d'outils](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-with-tool-use).

Le mode manuel ajoute une exigence : le dernier tour de l'assistant d'une requête avec réflexion activée doit commencer par un bloc de réflexion (la [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking) supprime cette exigence). Modifier la configuration de réflexion entre les tours invalide également la mise en cache des prompts ; consultez la section suivante.

## Mise en cache des prompts en mode manuel

Le mode manuel ajoute une règle en plus du comportement de mise en cache indépendant du mode décrit dans [réflexion et mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-prompt-caching) : modifier `budget_tokens` entre les requêtes invalide les points de rupture du cache, tout comme le changement de mode de réflexion, car la valeur du budget est intégrée au prompt. Les points de rupture au niveau des messages échouent toujours après un changement de budget ; le fait que les points de rupture des outils et de l'invite système échouent également dépend de l'endroit où le modèle intègre la configuration.

En pratique, choisissez un budget et maintenez-le stable pendant toute la durée d'une conversation mise en cache. Exécuter une conversation multi-tours avec mise en cache au niveau des messages sur Claude Sonnet 4.6 et modifier le budget lors de la troisième requête de 4 000 à 8 000 tokens montre directement l'invalidation :

```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 }
```

La troisième requête recrée le cache (`cache_creation_input_tokens=1370`, `cache_read_input_tokens=0`) car le budget a changé entre les requêtes. Pour une version exécutable de la même expérience en mode adaptatif, où le niveau d'effort joue le rôle de cache que `budget_tokens` joue ici, consultez [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost#prompt-caching) sur la page de pilotage.

## Mécanismes partagés

La plupart des comportements de réflexion sont indépendants du mode et documentés une seule fois sur la page [Réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking). Tout ce qui s'y trouve s'applique également en mode manuel :

* [Contrôler l'affichage de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#controlling-thinking-display)
* [Streaming de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#streaming-thinking)
* [Réflexion avec utilisation d'outils](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-with-tool-use), y compris la [préservation des blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#preserving-thinking-blocks)
* [Réflexion et mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-prompt-caching)
* [Réflexion et fenêtre de contexte](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-the-context-window)
* [Chiffrement de la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-encryption)
* [Tarification](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost#pricing) (sur la page [Piloter la réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost))

## Migrer vers la réflexion adaptative

Si votre modèle ne prend en charge que la réflexion étendue (Claude Sonnet 4.5 (déprécié), Claude Opus 4.5, Claude Haiku 4.5 et les modèles Claude 4 antérieurs), aucune action n'est nécessaire pour l'instant : la réflexion adaptative n'y est pas disponible, et `type: "adaptive"` [renvoie une erreur 400](https://platform.claude.com/docs/fr/build-with-claude/thinking-troubleshooting#error-thinking-type-adaptive). Conservez `budget_tokens` jusqu'à ce que vous passiez à un modèle qui prend en charge la réflexion adaptative, puis appliquez la correspondance qui suit.

Vous devez abandonner `type: "enabled"` si :

* Vous utilisez Claude Opus 4.6 ou Claude Sonnet 4.6, où `budget_tokens` est déprécié.
* Vous utilisez Claude 4.7 ou un modèle ultérieur, tel que Claude Opus 5.5, Claude Sonnet 5, Claude Sonnet 5.5, Claude Fable 5.1 ou Claude Haiku 5.5, où `type: "enabled"` renvoie une erreur 400.

La correspondance est simple : supprimez `budget_tokens`, définissez `thinking: {type: "adaptive"}`, et contrôlez la profondeur de raisonnement avec `output_config: {effort: ...}` au lieu d'un budget de tokens.

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

devient :

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

`effort: "high"` est la valeur par défaut sur Claude Sonnet 4.6, donc l'omettre ici produit un comportement identique ; il n'apparaît que pour montrer où se trouve le contrôle de la profondeur en mode adaptatif. Claude Opus 5.5 et Claude Haiku 5.5 utilisent `"medium"` par défaut, et les autres modèles qui prennent en charge l'effort utilisent `"high"` par défaut (consultez [Niveaux d'effort](https://platform.claude.com/docs/fr/build-with-claude/effort#effort-levels)).

Attendez-vous à une différence de comportement, et pas seulement à un changement de syntaxe. Avec un budget fixe, Claude réfléchit à chaque requête. Avec la réflexion adaptative, Claude détermine s'il doit réfléchir et dans quelle mesure pour chaque requête, et avec des paramètres d'[effort](https://platform.claude.com/docs/fr/build-with-claude/effort) plus faibles, il peut ignorer complètement la réflexion sur les entrées simples. Vous pouvez également supprimer l'en-tête bêta `interleaved-thinking-2025-05-14` après la migration : la réflexion adaptative s'entrelace automatiquement, et l'API Claude ignore l'en-tête sur ces modèles. La préservation des blocs de réflexion change aussi : Claude Opus 4.5 et les modèles numérotés 4.6 et supérieurs conservent les blocs de réflexion des tours précédents dans le contexte et les facturent comme entrée, alors que Claude Sonnet 4.5 (déprécié), Claude Haiku 4.5 et les modèles antérieurs les supprimaient ; consultez [préservation des blocs de réflexion par modèle](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-block-preservation-by-model).

Le changement de mode constitue une modification de la configuration de réflexion, de sorte que la première requête après le changement invalide les points de rupture du cache, comme décrit dans [Mise en cache des prompts en mode manuel](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching).

Pour des conseils complets, consultez [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking), [effort](https://platform.claude.com/docs/fr/build-with-claude/effort) et le [guide de migration des modèles](https://platform.claude.com/docs/fr/about-claude/models/migration-guide).

## Prochaines étapes

<CardGroup cols={3}>
  <Card title="Réflexion" icon="brain" href="https://platform.claude.com/docs/fr/build-with-claude/thinking">
    Découvrez le fonctionnement de la réflexion : blocs, affichage, streaming et utilisation d'outils.
  </Card>

  <Card title="Piloter la réflexion" icon="compass" href="https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost">
    Laissez Claude déterminer quand et dans quelle mesure réfléchir pour chaque requête.
  </Card>

  <Card title="Réflexion dans les flux de travail avec outils et multi-tours" icon="wrench" href="https://platform.claude.com/docs/fr/build-with-claude/thinking-tool-workflows">
    Préservez les blocs de réflexion et gérez la réflexion à travers les appels d'outils et les tours.
  </Card>
</CardGroup>