---
title: Effort
url: https://platform.claude.com/docs/fr/build-with-claude/effort
description: Contrôlez le nombre de tokens que Claude utilise pour répondre grâce au paramètre effort, en arbitrant entre l'exhaustivité des réponses et l'efficacité en tokens.
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
---

Le paramètre effort vous permet de contrôler le nombre de tokens que Claude dépense pour répondre aux requêtes. Vous pouvez arbitrer entre l'exhaustivité des réponses et l'efficacité en tokens avec un seul modèle. Le paramètre effort de niveau supérieur est disponible sur tous les modèles pris en charge, sans en-tête bêta requis. L'[effort par message](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) est en bêta.

<Tip>
  Pour comprendre comment l'effort interagit avec la réflexion et quel contrôle utiliser, consultez [Réflexion et effort](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-effort). Lorsque la réflexion adaptative est disponible, l'effort est le moyen recommandé pour contrôler la profondeur de réflexion.
</Tip>

## Définir le niveau d'effort

Définissez `output_config.effort` sur la requête. L'exemple suivant exécute une requête avec un effort `medium` et affiche le texte de la réponse.

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

## Fonctionnement de l'effort

La plupart des modèles Claude utilisent par défaut un effort élevé (high), en dépensant autant de tokens que nécessaire pour obtenir d'excellents résultats ; Claude Opus 5.5 et Claude Haiku 5.5 utilisent par défaut un effort moyen (medium). Vous pouvez augmenter le niveau d'effort jusqu'à `max` pour obtenir la capacité la plus élevée possible, ou le réduire pour être plus économe en tokens, en optimisant la vitesse et le coût tout en acceptant une certaine réduction des capacités.

<Tip>
  Définir `effort` sur la valeur par défaut du modèle (`"medium"` sur Claude Opus 5.5 et Claude Haiku 5.5, `"high"` sur les autres modèles) produit exactement le même comportement que l'omission complète du paramètre `effort`.
</Tip>

Le paramètre effort affecte **tous les tokens** de la réponse, notamment :

* Les réponses textuelles et les explications
* Les appels d'outils et les arguments de fonctions
* La réflexion (lorsqu'elle est active)

Comme l'effort s'applique à chaque token de sortie, il fonctionne que la réflexion soit activée ou non. Un effort plus faible signifie également des appels d'outils moins nombreux et plus concis.

### Niveaux d'effort

| Niveau   | Description                                                                                                                                                                                                                                                                                                                                           | Cas d'utilisation typique                                                                                               |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `max`    | Capacité maximale absolue, sans aucune contrainte sur la dépense de tokens. Disponible sur 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 et Claude Haiku 5.5. | Tâches nécessitant le raisonnement le plus approfondi possible et l'analyse la plus minutieuse                          |
| `xhigh`  | Capacité étendue pour les travaux de longue haleine. Disponible sur 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 et Claude Haiku 5.5.                                                                                   | Tâches agentiques et de codage de longue durée (plus de 30 minutes) avec des budgets de tokens se chiffrant en millions |
| `high`   | Dépense autant de tokens que la tâche l'exige pour obtenir d'excellents résultats. Valeur par défaut sur tous les modèles prenant en charge l'effort, à l'exception de Claude Opus 5.5 et Claude Haiku 5.5.                                                                                                                                           | Raisonnement complexe, problèmes de codage difficiles, tâches agentiques                                                |
| `medium` | Approche équilibrée avec des économies de tokens modérées. Valeur par défaut sur Claude Opus 5.5 et Claude Haiku 5.5.                                                                                                                                                                                                                                 | Tâches agentiques nécessitant un équilibre entre vitesse, coût et performances                                          |
| `low`    | Le plus efficace. Économies de tokens importantes avec une certaine réduction des capacités.                                                                                                                                                                                                                                                          | Tâches plus simples nécessitant la meilleure vitesse et les coûts les plus bas, comme les sous-agents                   |

Tous les modèles qui prennent en charge `max` ne prennent pas nécessairement en charge `xhigh`.

<Note>
  L'effort est un signal comportemental, et non un budget de tokens strict. Aux niveaux d'effort plus faibles, Claude réfléchit toujours sur les problèmes suffisamment difficiles, mais réfléchit moins qu'il ne le ferait à des niveaux d'effort plus élevés pour le même problème.
</Note>

Les recommandations par modèle qui suivent prévalent sur ce tableau lorsqu'elles diffèrent.

### Niveaux d'effort recommandés pour Claude Fable 5.1

Claude Fable 5.1 prend en charge les cinq niveaux d'effort. **Commencez par `high`, la valeur par défaut.** Passez à `xhigh` ou `max` pour les travaux agentiques et de codage les plus sensibles à la capacité, et descendez à `medium` ou `low` pour les travaux routiniers ou sensibles à la latence une fois que vos évaluations montrent que la qualité se maintient. À `high` et au-delà, définissez une valeur élevée pour `max_tokens`. Il s'agit d'une limite stricte sur la sortie totale (réflexion plus texte de réponse). Les mêmes recommandations s'appliquent à Claude Mythos 5.1. Consultez [Prompting de Claude Fable 5.1](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#consider-all-effort-levels).

Claude Fable 5.1 prend également en charge le [changement d'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) avec un `output_config` par message, ce qui préserve le cache de prompts.

### Niveaux d'effort recommandés pour Claude Fable 5

L'effort est le contrôle principal pour arbitrer entre intelligence, latence et coût sur Claude Fable 5. **Commencez par `high`, la valeur par défaut, pour la plupart des tâches**, utilisez `xhigh` pour les charges de travail les plus sensibles à la capacité, et descendez à `medium` ou `low` pour les travaux routiniers. Les réglages d'effort inférieurs sur Claude Fable 5 restent performants et dépassent souvent les performances de `xhigh` sur les modèles précédents. À `high` et `xhigh`, définissez une valeur élevée pour `max_tokens`. Il s'agit d'une limite stricte sur la sortie totale (réflexion plus texte de réponse). Consultez [Contrôle des coûts](https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost#cost-control).

Réduisez l'effort si une tâche aboutit mais prend plus de temps que nécessaire, ou si vous souhaitez un style de travail plus rapide et plus interactif. Les mêmes recommandations s'appliquent à Claude Mythos 5. Pour des conseils plus complets, consultez [Prompting de Claude Fable 5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-fable-5).

### Niveaux d'effort recommandés pour Claude Opus 5.5

Claude Opus 5.5 prend en charge les cinq niveaux d'effort, et `medium` est la valeur par défaut (Claude Opus 5 et les modèles Opus antérieurs utilisent `high` par défaut, de sorte qu'une requête qui omet `effort` s'exécute un niveau plus bas que sur Claude Opus 5). La réflexion adaptative est toujours active et ne peut pas être désactivée ; l'effort est donc le principal levier pour contrôler la quantité de raisonnement du modèle et le coût d'une requête. Effectuez un balayage des niveaux d'effort sur vos propres évaluations plutôt que de reprendre les réglages d'un modèle antérieur, et définissez une valeur élevée pour `max_tokens` aux niveaux supérieurs : il s'agit d'une limite stricte sur la sortie totale (réflexion plus texte de réponse). Les requêtes qui définissent `thinking: {"type": "disabled"}` renvoient une erreur 400 à tous les niveaux d'effort. Claude Opus 5.5 prend également en charge le [changement d'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) avec un `output_config` par message, ce qui préserve le cache de prompts. Consultez [Rédiger des prompts pour Claude Opus 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5-5).

### Niveaux d'effort recommandés pour Claude Opus 5

Claude Opus 5 prend en charge les cinq niveaux d'effort. **Commencez par `high`, la valeur par défaut**, et ajustez en fonction de vos évaluations : passez à `xhigh` pour les travaux de codage et agentiques exigeants, ou à `max` lorsqu'une tâche justifie une dépense de tokens sans contrainte, et utilisez largement `low` et `medium` comme principal contrôle du coût en tokens et du temps de réponse partout où vos évaluations montrent que la qualité se maintient. Si vous avez repris les réglages d'effort d'un modèle antérieur, effectuez un nouveau balayage des niveaux d'effort sur vos évaluations plutôt que de les réutiliser.

L'effort contrôle le volume de réflexion, et non la longueur visible de la réponse : sur Claude Opus 5, modifier l'effort ne raccourcit pas les réponses de manière fiable ; [indiquez plutôt la longueur souhaitée dans le prompt](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-opus-5#response-length-and-verbosity).

La valeur par défaut de l'API est `high`. Définissez `effort` explicitement pour utiliser un autre niveau. La valeur que vous transmettez remplace la valeur par défaut.

Sur Claude Opus 5, la réflexion ne peut pas être désactivée avec un effort `xhigh` ou `max` : les requêtes qui définissent `thinking: {"type": "disabled"}` à ces niveaux renvoient une erreur 400. Consultez [Effort avec la réflexion](https://platform.claude.com/docs/fr/build-with-claude/effort#effort-with-thinking).

Lorsque vous exécutez Claude Opus 5 avec un effort `xhigh` ou `max`, définissez une valeur élevée pour `max_tokens` afin que le modèle dispose de la marge nécessaire pour réfléchir et agir à travers les sous-agents et les appels d'outils. Commencer à 64k tokens et ajuster à partir de là constitue une valeur par défaut raisonnable.

Claude Opus 5 prend également en charge le [changement d'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) avec un `output_config` par message, ce qui préserve le cache des prompts. L'effort par message n'est pas disponible pour Claude Opus 5 sur Amazon Bedrock.

### Niveaux d'effort recommandés pour Claude Opus 4.8

Les conseils pour Claude Opus 4.7 s'appliquent également à Claude Opus 4.8. **Commencez par `xhigh` pour les cas d'utilisation de codage et agentiques**, utilisez `high` pour la plupart des autres charges de travail sensibles à l'intelligence, et ne descendez à `medium` ou `low` que lorsque vous avez mesuré que le niveau inférieur maintient la qualité sur vos évaluations.

La valeur par défaut de l'API est `high`. Définissez `effort` explicitement pour utiliser un niveau différent. La valeur que vous transmettez remplace la valeur par défaut.

Lorsque vous exécutez Claude Opus 4.8 avec un effort `xhigh` ou `max`, définissez une valeur élevée pour `max_tokens` afin que le modèle dispose de la marge nécessaire pour réfléchir et agir à travers les sous-agents et les appels d'outils. Commencer à 64k tokens et ajuster à partir de là constitue une valeur par défaut raisonnable.

### Niveaux d'effort recommandés pour Claude Opus 4.7

**Commencez par `xhigh` pour les cas d'utilisation de codage et agentiques**, et utilisez `high` comme minimum pour la plupart des charges de travail sensibles à l'intelligence. Descendez à `medium` pour les charges de travail sensibles aux coûts, ou montez à `max` uniquement lorsque vos évaluations montrent une marge de progression mesurable par rapport à `xhigh`.

La valeur par défaut de l'API est `high`. Pour utiliser `xhigh`, définissez `effort` explicitement. La valeur que vous transmettez remplace la valeur par défaut.

| Effort   | Recommandations pour Claude Opus 4.7                                                                                                                                                                                                                                                                                  |
| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `low`    | Efficace, mais plus adapté aux tâches courtes et bien délimitées. Associez `low` à des listes de contrôle explicites si votre tâche comporte plusieurs sections.                                                                                                                                                      |
| `medium` | Le choix direct pour un flux de travail moyen où vous souhaitez de bons résultats tout en réduisant les coûts.                                                                                                                                                                                                        |
| `high`   | Cas d'utilisation avancés qui nécessitent toujours un équilibre entre intelligence et consommation de tokens. C'est souvent le meilleur équilibre entre qualité et efficacité en tokens.                                                                                                                              |
| `xhigh`  | Le point de départ recommandé pour les travaux de codage et agentiques, ainsi que pour les tâches exploratoires telles que les appels d'outils répétés, la recherche web détaillée et la recherche dans une base de connaissances. Attendez-vous à une consommation de tokens nettement supérieure à celle de `high`. |
| `max`    | À réserver aux problèmes de pointe. Sur la plupart des charges de travail, `max` ajoute un coût important pour des gains de qualité relativement faibles, et sur certaines tâches à sortie structurée ou moins sensibles à l'intelligence, il peut entraîner une réflexion excessive.                                 |

Claude Opus 4.7 respecte également les niveaux d'effort plus strictement que Claude Opus 4.6, en particulier avec `low` et `medium`. Aux niveaux d'effort plus faibles, le modèle limite son travail à ce qui a été demandé plutôt que d'en faire plus que nécessaire. Si vous observez un raisonnement superficiel sur des problèmes complexes avec Claude Opus 4.7, augmentez l'effort plutôt que de contourner le problème par le prompt. Si vous devez maintenir un effort faible pour des raisons de latence, ajoutez des consignes ciblées comme « This task involves multistep reasoning. Think carefully before responding. »

Lorsque vous exécutez Claude Opus 4.7 avec un effort `xhigh` ou `max`, définissez une valeur élevée pour `max_tokens` afin que le modèle dispose de la marge nécessaire pour réfléchir et agir à travers les sous-agents et les appels d'outils. Commencer à 64k tokens et ajuster à partir de là constitue une valeur par défaut raisonnable.

### Niveaux d'effort recommandés pour Claude Sonnet 5.5

Claude Sonnet 5.5 prend en charge les cinq niveaux d'effort, et `high` est la valeur par défaut sur la Claude API. Ses niveaux sont recalibrés : un niveau donné ne produit donc pas la même quantité de réflexion que le même niveau sur Claude Sonnet 5. Effectuez un nouveau balayage des niveaux d'effort sur vos évaluations plutôt que de reprendre le réglage que vous utilisiez sur Claude Sonnet 5. Commencez par `high`, sauf si votre charge de travail est agentique ou sensible à la latence. Pour le codage agentique et l'utilisation d'outils en plusieurs étapes, commencez par `medium` pour les tâches bien spécifiées et passez à `high` pour les tâches plus difficiles ou plus longues. Pour le chat et les autres travaux sensibles à la latence, commencez par `medium` ou `low`. N'utilisez `xhigh` ou `max` que lorsque vos évaluations montrent un gain de qualité. Définissez `max_tokens` avec une marge suffisante pour la réflexion et la réponse. La réflexion est comptabilisée dans `max_tokens` même lorsque le contenu de la réflexion n'est pas renvoyé. Pour le codage agentique, définissez `max_tokens` sur 128 000, le maximum du modèle, et utilisez le [streaming](https://platform.claude.com/docs/fr/build-with-claude/streaming) pour la réponse.

Pour désactiver la réflexion préalable, envoyez `thinking: {"type": "between_tools"}` au lieu de `"disabled"`. Il s'agit du réglage de réflexion le plus bas sur Claude Sonnet 5.5, et il fonctionne avec un effort `low`, `medium` et `high`. Avec `xhigh` ou `max`, une requête qui l'utilise renvoie une erreur 400 ; utilisez donc la réflexion adaptative à ces niveaux : omettez le champ `thinking` ou envoyez `thinking: {"type": "adaptive"}`. Consultez [Exécution sans réflexion préalable](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking).

Claude Sonnet 5.5 prend également en charge le [changement d'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) avec un `output_config` par message, ce qui préserve le cache des prompts. Avec `between_tools`, l'effort ne peut pas changer en cours de conversation : un `output_config.effort` par message qui diffère du niveau en vigueur renvoie une erreur 400. Pour faire varier l'effort à chaque tour, utilisez la réflexion adaptative. Consultez [Rédiger des prompts pour Claude Sonnet 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort).

### Niveaux d'effort recommandés pour Claude Sonnet 5

Claude Sonnet 5 utilise par défaut l'effort `high` sur la Claude API et Claude Code.

* **Effort high (par défaut) :** Adapté au raisonnement complexe, au codage et aux tâches agentiques où la qualité importe plus que la vitesse ou le coût.
* **Effort xhigh :** Pour les tâches de codage et agentiques les plus difficiles. Consultez [Prompting de Claude Sonnet 5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-sonnet-5#calibrating-effort-and-thinking-depth).
* **Effort medium :** Niveau inférieur économique par rapport à la valeur par défaut. Comparable à Claude Sonnet 4.6 avec un effort high.
* **Effort low :** Pour les charges de travail à volume élevé ou sensibles à la latence. Adapté au chat et aux cas d'utilisation hors codage où un délai de réponse plus rapide est prioritaire.
* **Effort max :** Pour les tâches nécessitant la capacité la plus élevée possible sans contrainte sur la dépense de tokens.

### Niveaux d'effort recommandés pour Claude Sonnet 4.6

Sonnet 4.6 utilise par défaut un effort `high`. Définissez explicitement l'effort lorsque vous utilisez Sonnet 4.6 afin d'éviter une latence inattendue :

* **Effort medium** (valeur par défaut recommandée) : Meilleur équilibre entre vitesse, coût et performances pour la plupart des applications. Adapté au codage agentique, aux flux de travail faisant un usage intensif d'outils et à la génération de code.
* **Effort low :** Pour les charges de travail à volume élevé ou sensibles à la latence. Adapté au chat et aux cas d'utilisation hors codage où un délai de réponse plus rapide est prioritaire.
* **Effort high :** Pour le raisonnement complexe et les tâches où la qualité compte davantage que la vitesse ou le coût.
* **Effort max :** Pour les tâches nécessitant la capacité la plus élevée possible, sans aucune contrainte sur la dépense de tokens.

### Niveaux d'effort recommandés pour Claude Haiku 5.5

Claude Haiku 5.5 prend en charge les cinq niveaux d'effort, et `medium` est la valeur par défaut. L'effort est le principal contrôle de la quantité de réflexion du modèle et, par conséquent, de la qualité, de la latence et du coût. **Commencez par `medium`** pour la plupart des travaux, y compris le codage agentique. Utilisez `low`, le niveau le moins cher et le plus rapide, pour le chat, les tâches courtes impliquant des outils et les requêtes simples à volume élevé. Dans les longs prompts d'agent, le modèle est plus susceptible de sauter une recherche, de s'arrêter prématurément ou de sauter une vérification avec `low`. Utilisez `high` pour le travail intellectuel, les tâches d'agent plus longues et le respect strict des instructions. N'utilisez `xhigh` ou `max` que lorsque vos évaluations montrent un gain de qualité, et comparez-les avec Claude Sonnet 5.5 en termes de performance, de coût et de vitesse. La réflexion est activée par défaut et est comptabilisée dans `max_tokens` ; prévoyez donc une marge suffisante. Consultez [Rédiger des prompts pour Claude Haiku 5.5](https://platform.claude.com/docs/fr/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).

Pour obtenir moins de réflexion, réduisez le niveau d'effort. Vous pouvez également envoyer `thinking: {"type": "disabled"}` avec un effort `high` ou inférieur. Avec `xhigh` ou `max`, cela renvoie une erreur 400 ; utilisez donc la réflexion adaptative à ces niveaux : omettez le champ `thinking` ou envoyez `thinking: {"type": "adaptive"}`.

Sur la Claude API et Google Cloud, Claude Haiku 5.5 prend également en charge le [changement d'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) avec un `output_config` par message, ce qui préserve le cache des prompts. Avec `thinking: {"type": "disabled"}`, l'effort ne peut pas changer en cours de conversation : un `output_config.effort` par message qui diffère du niveau en vigueur renvoie une erreur 400. Pour faire varier l'effort à chaque tour, utilisez la réflexion adaptative.

## Effort avec l'utilisation d'outils

Lors de l'« tool use » (utilisation d'outils), le paramètre effort affecte à la fois les explications entourant les appels d'outils et les appels d'outils eux-mêmes. Les niveaux d'effort inférieurs ont tendance à :

* Combiner plusieurs opérations en moins d'appels d'outils
* Effectuer moins d'appels d'outils
* Passer directement à l'action sans préambule
* Utiliser des messages de confirmation concis après achèvement

Les niveaux d'effort supérieurs peuvent :

* Effectuer davantage d'appels d'outils
* Expliquer le plan avant d'agir
* Fournir des résumés détaillés des modifications
* Inclure des commentaires de code plus complets

## Effort avec la réflexion

Le paramètre `thinking` contrôle si Claude réfléchit dans des [blocs de réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking) avant de répondre ; le paramètre `effort` contrôle la quantité de travail que Claude consacre à l'ensemble de la réponse, ce qui, en mode adaptatif, inclut la fréquence et la profondeur de sa réflexion. Ne passez pas `adaptive` comme valeur de `effort` : `adaptive` est un mode de réflexion, et non un niveau d'effort.

Aux niveaux d'effort supérieurs, Claude réfléchit plus volontiers et plus longuement. Dans une boucle d'utilisation d'outils, les requêtes de suivi qui ne font que traiter des résultats d'outils peuvent toujours ignorer la réflexion, quel que soit le niveau. Aux niveaux inférieurs, Claude peut ignorer entièrement la réflexion pour les problèmes plus simples. Consultez [Réflexion et effort](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-effort) pour des conseils complets sur la façon dont ces deux contrôles fonctionnent ensemble.

Sur Claude Opus 4.5, le seul modèle à « extended thinking » (réflexion étendue) uniquement qui prend en charge l'effort, celui-ci fonctionne conjointement avec [`budget_tokens`](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking) : définissez le niveau d'effort pour votre tâche, puis définissez le budget de tokens de réflexion en fonction de la profondeur de raisonnement requise par la tâche.

Pour la disponibilité de la réflexion par modèle, consultez le [tableau de configuration par modèle](https://platform.claude.com/docs/fr/build-with-claude/thinking-troubleshooting#supported-models). L'effort fonctionne avec ou sans réflexion. Consultez [Fonctionnement de l'effort](https://platform.claude.com/docs/fr/build-with-claude/effort#how-effort-works).

## Changer l'effort en cours de conversation

Vous pouvez exécuter les tours ultérieurs d'une conversation à un niveau d'effort différent de deux manières. Sur Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 et Claude Haiku 5.5, utilisez un changement d'effort par message, qui conserve le cache des prompts. Sur les autres modèles, définissez une nouvelle valeur de niveau supérieur dans la requête suivante, ce qui réinitialise le cache.

### Effort par message (bêta)

L'effort par message est en bêta. Sur la Claude API et [Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-on-vertex-ai), il est disponible sur Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 et Claude Haiku 5.5. Sur [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), il est disponible sur Claude Fable 5.1, Claude Mythos 5.1 et Claude Opus 5.5. Il nécessite l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `mid-conversation-output-config-2026-07-01`. Avec l'[API InvokeModel](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy) d'Amazon Bedrock, il est disponible sur Claude Fable 5.1 et Claude Opus 5.5, et vous envoyez plutôt cette valeur dans le tableau `anthropic_beta` du corps de la requête.

Sans la valeur bêta, un `output_config` par message renvoie une erreur 400 : `messages.N.output_config: Extra inputs are not permitted`, où `N` est l'index du message `system` dans `messages`. Avec la valeur bêta, les modèles sans effort par message, y compris Claude Fable 5, renvoient une erreur 400 : `output_config.effort requires a model that supports per-turn effort; this model does not`. Sur Amazon Bedrock, ces modèles ainsi que Claude Opus 5 renvoient plutôt l'erreur `Extra inputs are not permitted`. Sur Claude Sonnet 5.5 avec `thinking: {"type": "between_tools"}` et sur Claude Haiku 5.5 avec `thinking: {"type": "disabled"}`, l'effort ne peut pas changer en cours de conversation : un `output_config.effort` par message qui diffère du niveau en vigueur renvoie une erreur 400. Pour faire varier l'effort à chaque tour, utilisez la réflexion adaptative.

Ajoutez un message `role: "system"` avec un `content` vide et le nouveau niveau dans `output_config.effort`. Placé directement après un tour `user` contenant une nouvelle entrée, il définit le niveau de la réponse de Claude à ce tour. Placé ailleurs, par exemple entre un tour `assistant` et le tour `user` suivant comme dans l'exemple ci-dessous, il prend effet à partir du prochain tour `user` contenant une nouvelle entrée. Un tour `user` qui ne contient que des blocs `tool_result` ne compte pas comme une nouvelle entrée ; un changement placé après un tel tour dans une boucle d'utilisation d'outils attend donc le prochain tour `user` contenant une nouvelle entrée. Le nouveau niveau reste ensuite en vigueur jusqu'à ce qu'un message ultérieur le modifie. Tout ce qui précède ce message reste inchangé, de sorte que le préfixe mis en cache correspond toujours.

L'exemple suivant commence avec `high`, puis descend à `low` pour une question de suivi routinière :

<CodeGroup>
  ```bash cURL
  # Message système limité à l'effort : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
  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."
    # Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
    - 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.",
          },
          # Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
          {"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."
      },
      // Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
      { 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." },
          // Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour de l'utilisateur.
          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.")},
  		},
  		// Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
  		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.")
          // Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
          .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.'),
          // Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
          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."},
      # Message système d'effort uniquement : le nouveau niveau s'applique à partir du prochain tour utilisateur.
      {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>

Un message système ne contenant que l'effort ne comporte aucun texte ; les [règles de placement des messages système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages#limitations) ne s'appliquent donc pas. Il peut apparaître n'importe où dans `messages`, y compris en tant que première entrée ou entre un tour `assistant` et le tour `user` suivant. Les valeurs sont les noms des niveaux (`low`, `medium`, `high`, `xhigh` et `max`).

Privilégiez cette forme plutôt que de modifier la valeur de niveau supérieur entre les requêtes. Un changement de niveau supérieur réinitialise le cache et, sur Claude Fable 5.1, oriente également le modèle de manière moins fiable : ses réponses antérieures ont été rédigées au niveau précédent, et il a tendance à rester cohérent avec elles.

### Effort de niveau supérieur sur la requête suivante

Le paramètre `output_config.effort` de niveau supérieur s'applique à l'ensemble de la requête. Pour exécuter une partie ultérieure d'une conversation à un niveau différent, définissez la nouvelle valeur sur la requête suivante. Comme l'effort de niveau supérieur façonne le prompt rendu, le modifier entre les requêtes ne préserve pas les préfixes mis en cache des tours précédents. Si vous comptez sur la [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) tout au long d'une longue session et que votre modèle ne prend pas en charge l'effort par message, choisissez un niveau d'effort au départ et maintenez-le constant.

## Bonnes pratiques

1. **Définissez l'effort explicitement :** L'API utilise `high` par défaut (`medium` sur Claude Opus 5.5 et Claude Haiku 5.5), mais le bon point de départ dépend de votre modèle et de votre charge de travail.
2. **Utilisez low pour les tâches sensibles à la vitesse ou simples :** Lorsque la latence compte ou que les tâches sont simples, un effort faible peut réduire considérablement les temps de réponse et les coûts.
3. **Testez votre cas d'utilisation :** L'impact des niveaux d'effort varie selon le type de tâche. Évaluez les performances sur vos cas d'utilisation spécifiques avant le déploiement.
4. **Envisagez un effort dynamique :** Ajustez l'effort en fonction de la complexité de la tâche. Les requêtes simples peuvent justifier un effort faible, tandis que le codage agentique et le raisonnement complexe bénéficient d'un effort élevé. Consultez le point suivant avant de le faire varier au sein d'une même conversation.
5. **Maintenez l'effort de niveau supérieur constant dans les conversations mises en cache :** Modifier la valeur d'effort de niveau supérieur entre les requêtes invalide la [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) ; faites-la donc varier d'une charge de travail à l'autre plutôt qu'au sein d'une conversation qui repose sur des succès de cache. Sur les modèles qui le prennent en charge, utilisez plutôt un [changement d'effort par message](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta), qui préserve le cache. Consultez [Réflexion et mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/thinking#thinking-and-prompt-caching).

## Étapes suivantes

<CardGroup>
  <Card title="Budgets de tâche" icon="gauge" href="https://platform.claude.com/docs/fr/build-with-claude/task-budgets">
    Donnez à Claude un budget de tokens indicatif pour l'ensemble de la boucle agentique afin d'aider le modèle à s'autoréguler sur les longues tâches agentiques.
  </Card>

  <Card title="Orienter la réflexion" icon="compass" href="https://platform.claude.com/docs/fr/build-with-claude/thinking-steering-and-cost">
    Comprenez la réflexion adaptative, où Claude détermine quand et combien réfléchir, et orientez-la avec l'effort et les prompts.
  </Card>

  <Card title="Réflexion" icon="brain" href="https://platform.claude.com/docs/fr/build-with-claude/thinking">
    Comprenez le fonctionnement de la réflexion, quand Claude réfléchit par défaut et comment la réflexion interagit avec l'effort.
  </Card>
</CardGroup>