Pensée adaptative

La pensée adaptative est la méthode recommandée à utiliser Réflexion étendue avec la Claude Opus version 4.6. Au lieu de définir manuellement un budget symbolique, la pensée adaptative permet de décider Claude dynamiquement quand et dans quelle mesure réfléchir en fonction de la complexité de chaque demande. La pensée adaptative génère de manière fiable de meilleures performances que la pensée étendue avec une approche fixebudget_tokens, et nous vous recommandons de passer à la pensée adaptative pour obtenir les réponses les plus intelligentes à partir de la Claude Opus version 4.6. Aucun en-tête bêta n'est requis.

Les modèles suivants sont pris en charge :

Modèle	ID du modèle
Claude Opus 5	anthropic.claude-opus-5
Claude Mythos 5	anthropic.claude-mythos-5
Claude Fable 5	anthropic.claude-fable-5
Claude Opus4,7	anthropic.claude-opus-4-7
Aperçu de Claude Mythos	anthropic.claude-mythos-preview
Claude Opus4,6	anthropic.claude-opus-4-6-v1
Claude Sonnet 4,6	anthropic.claude-sonnet-4-6

Note

Claude Mythos 5, Claude Fable 5, Claude Opus 4.7 et Claude Mythos Preview ne prennent en charge que la pensée adaptative. La pensée manuelle étendue (thinking.type: "enabled"avecbudget_tokens) et la pensée handicapée (thinking.type: "disabled") ne sont pas prises en charge sur ces modèles et renverront une erreur 400. À utiliser thinking.type: "adaptive" avec output_config.effort pour contrôler le comportement cognitif.

thinking.type: "enabled"et budget_tokens sont obsolètes sur les versions Claude Opus 4.6 et Claude Sonnet 4.6 et seront supprimées dans une future version du modèle. thinking.type: "adaptive"Utilisez-le plutôt avec le paramètre d'effort.

Les modèles plus anciens (Claude Opus4.5Claude Sonnet 4.5, etc.) ne favorisent pas la pensée adaptative et nécessitent thinking.type: "enabled" avecbudget_tokens.

Comment fonctionne la pensée adaptative

En mode adaptatif, Claude évalue la complexité de chaque demande et décide s'il faut réfléchir et dans quelle mesure. Au niveau d'effort par défaut (high), je Claude réfléchirai presque toujours. À des niveaux d'effort plus faibles, vous Claude pouvez ne pas penser à des problèmes plus simples.

La pensée adaptative s'active également automatiquementRéflexion entrelacée (bêta). Cela signifie qu'il est Claude possible de réfléchir entre les appels d'outils, ce qui le rend particulièrement efficace pour les flux de travail des agences.

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

CLI

aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'

Python

import boto3
import json

bedrock_runtime = boto3.client(
    service_name='bedrock-runtime',
    region_name='us-east-2'
)

response = bedrock_runtime.invoke_model(
    modelId="us.anthropic.claude-opus-4-6-v1",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 16000,
        "thinking": {
            "type": "adaptive"
        },
        "messages": [{
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even."
        }]
    })
)

response_body = json.loads(response["body"].read())

for block in response_body["content"]:
    if block["type"] == "thinking":
        print(f"\nThinking: {block['thinking']}")
    elif block["type"] == "text":
        print(f"\nResponse: {block['text']}")

TypeScript

import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";

async function main() {
    const client = new BedrockRuntimeClient({});

    const command = new InvokeModelCommand({
        modelId: "us.anthropic.claude-opus-4-6-v1",
        body: JSON.stringify({
            anthropic_version: "bedrock-2023-05-31",
            max_tokens: 16000,
            thinking: {
                type: "adaptive"
            },
            messages: [{
                role: "user",
                content: "Explain why the sum of two even numbers is always even."
            }]
        })
    });

    const response = await client.send(command);
    const responseBody = JSON.parse(new TextDecoder().decode(response.body));

    for (const block of responseBody.content) {
        if (block.type === "thinking") {
            console.log(`\nThinking: ${block.thinking}`);
        } else if (block.type === "text") {
            console.log(`\nResponse: ${block.text}`);
        }
    }
}

main().catch(console.error);

Pensée adaptative avec le paramètre d'effort

Vous pouvez combiner la pensée adaptative avec le paramètre d'effort pour déterminer l'efficacité de la Claude réflexion. Le niveau d'effort agit comme une indication souple pour Claude la répartition de la réflexion :

Niveau d'effort	Comportement de réflexion
max	Claudepense toujours sans aucune contrainte quant à la profondeur de la réflexion. Claude Opus4.6 et Claude Opus 5 uniquement — les requêtes utilisant max d'autres modèles renverront une erreur.
xhigh	Claudepense toujours avec une grande profondeur. Claude Opus 5 et Claude Opus 4.6 uniquement.
high (par défaut)	Claudepense toujours. Fournit un raisonnement approfondi sur des tâches complexes.
medium	Claudeutilise une pensée modérée. Peut ne pas penser à des requêtes très simples.
low	Claudeminimise la réflexion. Oublie de penser aux tâches simples où la rapidité compte le plus.

Important

Le effort paramètre doit être placé à l'intérieur d'un output_config objet distinct du corps de votre requête, et non à l'intérieur de l'thinkingobjet. Le placement effort à l'intérieur thinking se traduira par unValidationException.

Important

Limite d'effort lorsque la pensée est désactivée (Claude Opus 5) : Claude Opus 5 soutient"thinking": {"type": "disabled"}, mais lorsque la pensée est désactivée, elle output_config.effort est plafonnée àhigh. Les demandes accompagnées xhigh d'un max effort combiné à un trouble de la pensée renverront uninvalid_request_error. Ce plafond s'applique également à l'effort par tour défini par le biais d'un message système en cours de conversation. Pour utiliser xhigh ou faire max un effort, activez la pensée adaptative (par défaut) ou omettez complètement le thinking paramètre.

L'exemple suivant montre comment définir le niveau d'effort lors de l'utilisation de l' InvokeModel API :

{
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive"
    },
    "output_config": {
        "effort": "high"
    },
    "messages": [{
        "role": "user",
        "content": "Your prompt here"
    }]
}

Utiliser la pensée adaptative avec l'API Converse

Lorsque vous utilisez l'API Converse, transmettez les effort paramètres thinking et à l'intérieuradditionalModelRequestFields. L'exemple suivant illustre la pensée adaptative avec le niveau d'effort par défaut :

import boto3, json

bedrock_runtime = boto3.client(service_name='bedrock-runtime', region_name='us-east-2')

response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-6-v1",
    messages=[{
        "role": "user",
        "content": [{"text": "Explain why the sum of two even numbers is always even."}]
    }],
    additionalModelRequestFields={
        "thinking": {
            "type": "adaptive"
        }
    }
)

print(json.dumps(response["output"], indent=2, default=str))

Pour spécifier un niveau d'effort, ajoutez le effort champ à l'intérieur d'un output_config objet distinct dans additionalModelRequestFields :

response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-6-v1",
    messages=[{
        "role": "user",
        "content": [{"text": "What is 2 + 2?"}]
    }],
    additionalModelRequestFields={
        "thinking": {
            "type": "adaptive"
        },
        "output_config": {
            "effort": "low"
        }
    }
)

Mise en cache des invites

Les requêtes consécutives utilisant adaptive Thinking préservent les points d'arrêt rapides du cache. Cependant, le basculement entre les modes adaptive etenabled/disabledthinking interrompt les points d'arrêt du cache pour les messages. Les instructions système et les définitions d'outils restent mises en cache indépendamment des changements de mode.

Régler le comportement de réflexion

Si vous Claude pensez plus ou moins souvent que vous ne le souhaiteriez, vous pouvez ajouter des instructions à l'invite de votre 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.

Avertissement

Le fait Claude de réfléchir moins souvent peut réduire la qualité des tâches qui bénéficient du raisonnement. Mesurez l'impact sur vos charges de travail spécifiques avant de déployer un réglage rapide pour la production. Envisagez d'abord de faire des tests avec des niveaux d'effort inférieurs.

Récapitulatif du texte du connecteur (version bêta)

Sur Claude Fable 5, le texte que le modèle émet entre les appels d'outils (parfois appelé « texte du connecteur », par exemple, « Laissez-moi vérifier ce fichier ensuite... ») est résumé côté serveur et renvoyé sous forme de bloc de réflexion plutôt que de bloc de contenu en texte brut. Le bloc de réflexion utilise la même forme que n'importe quel autre bloc de réflexion (texte vide avec une signature sous l'omittedaffichage par défaut).

Impact sur les clients :

• Forme de réponse : Tool-use les réponses de Claude Fable 5 peuvent contenir des blocs de réflexion supplémentaires alors que les modèles précédents émettaient du texte brut entre les tool_use blocs. Il n'existe aucun nouveau type de bloc de contenu. Les réponses finales de l'assistant (une fois que tous les outils sont utilisés) ne sont pas affectées et restent en texte brut.

• Multi-turn gestion : retransmettez ces blocs de réflexion inchangés dans les conversations à plusieurs tours, de la même manière que la pensée protégée (signature validée lors du repassback ; supprimée silencieusement si elle est envoyée vers un autre modèle).

• Champ d'application : le résumé des connecteurs ne s'applique qu'une fois qu'tool_resultil existe dans la conversation. La narration avant le premier appel à l'outil dans une nouvelle conversation reste en texte brut. Les segments de texte courts peuvent être transmis sous forme de texte brut sans résumé.

Cette fonctionnalité est activée côté serveur pour Claude Fable 5. Il n'y a pas d'opt-in ou de opt-out pour le client.