Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pensée adaptative

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, au lieu de nécessiter un budget symbolique fixe. Il est compatible avec Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5, Claude Sonnet 5 et d'autres modèles capables de réfléchir. La pensée adaptative génère de manière fiable de meilleures performances que la pensée étendue avec une solution fixebudget_tokens. Aucun en-tête bêta n'est requis.

Les modèles suivants sont pris en charge :

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 :

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"
        }
    }
)

Régler l'effort par tour (bêta)

Cette fonctionnalité est un service bêta tel que défini dans les conditions du service AWS. Sur Claude Fable 5.1 et Claude Mythos 5.1, vous pouvez modifier le niveau d'effort en cours de conversation au lieu de le définir une seule fois pour l'ensemble de la demande. Insérez un message système contenant une output_config.effort valeur à n'importe quel point du messages tableau. Le nouveau niveau d'effort s'applique aux virages qui le suivent. La demande renvoie 200 sans modification de la forme de la réponse.

Pour utiliser l'effort par tour, incluez l'une des anthropic_beta valeurs suivantes :mid-conversation-output-config-2026-07-01, mid-conversation-effort-2026-08-01per-turn-control-2026-07-01, ouper-message-effort-2026-07-01.

{
    "anthropic_version": "bedrock-2023-05-31",
    "anthropic_beta": ["mid-conversation-effort-2026-08-01"],
    "max_tokens": 16000,
    "output_config": {"effort": "high"},
    "messages": [
        {"role": "user", "content": "First question"},
        {"role": "assistant", "content": "First answer"},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "A simpler follow-up question"}
    ]
}

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, quels que soient les 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.

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 :

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.