Pensée adaptative

La pensée adaptative est la façon recommandée d'utiliser la pensée étendue avec Claude Opus 4.6. Au lieu de définir manuellement un budget de jetons de pensée, la pensée adaptative permet à Claude de décider dynamiquement quand et combien penser en fonction de la complexité de chaque demande.

Modèles supportés

La pensée adaptative est supportée sur les modèles suivants :

• Claude Opus 4.6 (claude-opus-4-6)

Comment fonctionne la pensée adaptative

En mode adaptatif, la pensée est optionnelle pour le modèle. Claude évalue la complexité de chaque demande et décide s'il doit penser et combien. Au niveau d'effort par défaut (high), Claude pensera presque toujours. Aux niveaux d'effort inférieurs, Claude peut ignorer la pensée pour les problèmes plus simples.

La pensée adaptative active également automatiquement la pensée entrelacée. Cela signifie que Claude peut penser entre les appels d'outils, ce qui la rend particulièrement efficace pour les flux de travail agentiques.

Comment utiliser la pensée adaptative

Définissez thinking.type sur "adaptive" dans votre demande API :

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-opus-4-6",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive"
    },
    "messages": [
        {
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even."
        }
    ]
}'

Pensée adaptative avec le paramètre effort

Vous pouvez combiner la pensée adaptative avec le paramètre effort pour guider la quantité de pensée que Claude fait. Le niveau d'effort agit comme une orientation douce pour l'allocation de pensée de Claude :

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={
        "type": "adaptive"
    },
    output_config={
        "effort": "medium"
    },
    messages=[{
        "role": "user",
        "content": "What is the capital of France?"
    }]
)

print(response.content[0].text)

Streaming avec pensée adaptative

La pensée adaptative fonctionne de manière transparente avec le streaming. Les blocs de pensée sont diffusés via les événements thinking_delta tout comme le mode de pensée manuel :

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[{"role": "user", "content": "What is the greatest common divisor of 1071 and 462?"}],
) as stream:
    for event in stream:
        if event.type == "content_block_start":
            print(f"\nStarting {event.content_block.type} block...")
        elif event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                print(event.delta.thinking, end="", flush=True)
            elif event.delta.type == "text_delta":
                print(event.delta.text, end="", flush=True)

Pensée adaptative vs manuelle vs désactivée

Considérations importantes

Changements de validation

Lors de l'utilisation de la pensée adaptative, les tours d'assistant précédents n'ont pas besoin de commencer par des blocs de pensée. C'est plus flexible que le mode manuel, où l'API impose que les tours avec pensée activée commencent par un bloc de pensée.

Mise en cache des invites

Les demandes consécutives utilisant la pensée adaptive préservent les points d'arrêt du cache d'invite. Cependant, basculer entre les modes de pensée adaptive et enabled/disabled casse les points d'arrêt du cache pour les messages. Les invites système et les définitions d'outils restent en cache indépendamment des changements de mode.

Ajustement du comportement de pensée

Le comportement de déclenchement de la pensée adaptative est invitable. Si Claude pense plus ou moins souvent que vous le souhaitez, vous pouvez ajouter des conseils à votre invite système :

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

Contrôle des coûts

Utilisez max_tokens comme limite stricte sur la sortie totale (pensée + texte de réponse). Le paramètre effort fournit une orientation douce supplémentaire sur la quantité de pensée que Claude alloue. Ensemble, ces éléments vous donnent un contrôle efficace sur les coûts.

Aux niveaux d'effort high et max, Claude peut penser plus extensivement et peut être plus susceptible d'épuiser le budget max_tokens. Si vous observez stop_reason: "max_tokens" dans les réponses, envisagez d'augmenter max_tokens pour donner plus d'espace au modèle, ou baissez le niveau d'effort.

Travailler avec les blocs de pensée

Les concepts suivants s'appliquent à tous les modèles qui supportent la pensée étendue, que vous utilisiez le mode adaptatif ou manuel.

Pensée résumée

With extended thinking enabled, the Messages API for Claude 4 models returns a summary of Claude's full thinking process. Summarized thinking provides the full intelligence benefits of extended thinking, while preventing misuse.

Here are some important considerations for summarized thinking:

• You're charged for the full thinking tokens generated by the original request, not the summary tokens.
• The billed output token count will not match the count of tokens you see in the response.
• The first few lines of thinking output are more verbose, providing detailed reasoning that's particularly helpful for prompt engineering purposes.
• As Anthropic seeks to improve the extended thinking feature, summarization behavior is subject to change.
• Summarization preserves the key ideas of Claude's thinking process with minimal added latency, enabling a streamable user experience and easy migration from Claude Sonnet 3.7 to Claude 4 and later models.
• Summarization is processed by a different model than the one you target in your requests. The thinking model does not see the summarized output.

Chiffrement de la pensée

Full thinking content is encrypted and returned in the signature field. This field is used to verify that thinking blocks were generated by Claude when passed back to the API.

Here are some important considerations on thinking encryption:

• When streaming responses, the signature is added via a signature_delta inside a content_block_delta event just before the content_block_stop event.
• signature values are significantly longer in Claude 4 models than in previous models.
• The signature field is an opaque field and should not be interpreted or parsed - it exists solely for verification purposes.
• signature values are compatible across platforms (Claude APIs, Amazon Bedrock, and Vertex AI). Values generated on one platform will be compatible with another.

Rédaction de la pensée

Occasionally Claude's internal reasoning will be flagged by our safety systems. When this occurs, we encrypt some or all of the thinking block and return it to you as a redacted_thinking block. redacted_thinking blocks are decrypted when passed back to the API, allowing Claude to continue its response without losing context.

When building customer-facing applications that use extended thinking:

• Be aware that redacted thinking blocks contain encrypted content that isn't human-readable
• Consider providing a simple explanation like: "Some of Claude's internal reasoning has been automatically encrypted for safety reasons. This doesn't affect the quality of responses."
• If showing thinking blocks to users, you can filter out redacted blocks while preserving normal thinking blocks
• Be transparent that using extended thinking features may occasionally result in some reasoning being encrypted
• Implement appropriate error handling to gracefully manage redacted thinking without breaking your UI

Here's an example showing both normal and redacted thinking blocks:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me analyze this step by step...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "Based on my analysis..."
    }
  ]
}

When passing thinking and redacted_thinking blocks back to the API in a multi-turn conversation, you must include the complete unmodified block back to the API for the last assistant turn. This is critical for maintaining the model's reasoning flow. We suggest always passing back all thinking blocks to the API. For more details, see the Preserving thinking blocks section.

Tarification

For complete pricing information including base rates, cache writes, cache hits, and output tokens, see the pricing page.

The thinking process incurs charges for:

• Tokens used during thinking (output tokens)
• Thinking blocks from the last assistant turn included in subsequent requests (input tokens)
• Standard text output tokens

When using summarized thinking:

• Input tokens: Tokens in your original request (excludes thinking tokens from previous turns)
• Output tokens (billed): The original thinking tokens that Claude generated internally
• Output tokens (visible): The summarized thinking tokens you see in the response
• No charge: Tokens used to generate the summary

Sujets supplémentaires

La page de pensée étendue couvre plusieurs sujets en plus de détail avec des exemples de code spécifiques au mode :

• Utilisation d'outils avec pensée : Les mêmes règles s'appliquent pour la pensée adaptative — préservez les blocs de pensée entre les appels d'outils et soyez conscient des limitations de tool_choice quand la pensée est active.
• Mise en cache des invites : Avec la pensée adaptative, les demandes consécutives utilisant le même mode de pensée préservent les points d'arrêt du cache. Basculer entre les modes adaptive et enabled/disabled casse les points d'arrêt du cache pour les messages (les invites système et les définitions d'outils restent en cache).
• Fenêtres de contexte : Comment les jetons de pensée interagissent avec max_tokens et les limites de la fenêtre de contexte.

Prochaines étapes