Configuration du modèle

Configurez le modèle utilisé par Claude Code, les niveaux d'effort, le contexte étendu et la fenêtre d'auto-compaction

Modèles disponibles

Pour le paramètre model dans Claude Code, vous pouvez configurer l'un des éléments suivants :

• Un alias de modèle
• Un nom de modèle
  • API Anthropic : un nom de modèle complet
  • Amazon Bedrock : un ARN de profil d'inférence
  • Microsoft Foundry : un nom de déploiement
  • Agent Platform de Google Cloud : un nom de version

Pour obtenir des conseils sur le modèle et le niveau d'effort qui conviennent à différents types de travail, consultez Choisir un modèle Claude et un niveau d'effort dans Claude Code sur le blog.

[!NOTE]

ANTHROPIC_BASE_URL change l'endroit où les requêtes sont envoyées, non le modèle qui y répond. Pour acheminer Claude via une passerelle LLM, consultez Passerelles LLM.

Alias de modèles

Utilisez un alias de modèle pour sélectionner les paramètres du modèle sans mémoriser les numéros de version exacts :

Les alias opus, sonnet et haiku se résolvent à la version la plus récente sur l'API Anthropic et à une version antérieure chez certains autres fournisseurs :

Sauf si vous définissez ANTHROPIC_DEFAULT_FABLE_MODEL, l'alias fable se résout à Fable 5 dans les sessions de passerelle d'applications Claude et à Fable 5.2 partout ailleurs.

Une passerelle qui n'est pas configurée pour servir claude-fable-5-2 rejette les requêtes pour ce modèle. Pour utiliser Fable 5.2 via une passerelle qui le sert, sélectionnez-le avec /model claude-fable-5-2.

Lorsque opus ou sonnet se résout à un modèle plus ancien, les modèles plus récents sont disponibles en sélectionnant explicitement le nom de modèle complet ou en définissant ANTHROPIC_DEFAULT_OPUS_MODEL ou ANTHROPIC_DEFAULT_SONNET_MODEL.

Les versions antérieures résolvent ces alias à des modèles plus anciens. Pour la version à laquelle chaque alias a changé, consultez Historique des versions.

Les alias pointent vers la version recommandée pour votre fournisseur et se mettent à jour au fil du temps. Pour épingler une version spécifique, utilisez le nom de modèle complet, par exemple claude-opus-5-5, ou définissez la variable d'environnement correspondante comme ANTHROPIC_DEFAULT_OPUS_MODEL.

[!NOTE]

Sonnet 5.5 nécessite Claude Code v2.1.284 ou ultérieur, et Opus 5.5 nécessite v2.1.280 ou ultérieur. Si une requête pour l'un d'eux à partir d'une version plus ancienne échoue, consultez Claude Code ne supporte pas ce modèle. Utilisez v2.1.293 ou ultérieur avec Haiku 5.5. Exécutez claude update pour mettre à jour.

Travailler avec Fable

Les modèles Claude Fable sont les modèles les plus puissants de Claude Code, adaptés aux tâches plus importantes qu'une seule séance. Ils maintiennent de longues sessions autonomes, enquêtent avant d'agir et vérifient leur travail plus souvent que les modèles plus petits.

Aucun modèle Fable n'est la valeur par défaut du type de compte sur aucun plan ou fournisseur. Sélectionnez-en un explicitement :

• Fable 5.2 : exécutez /model fable, ou lancez avec claude --model fable. Dans les sessions de passerelle d'applications Claude, exécutez plutôt /model claude-fable-5-2.
• Fable 5.1 ou Fable 5 : sélectionnez-le par ID de modèle. Sur l'API Anthropic, exécutez /model claude-fable-5-1 ou /model claude-fable-5, ou lancez avec claude --model claude-fable-5-1. Sur d'autres fournisseurs, utilisez l'ID de modèle de votre fournisseur ou épinglez-le avec ANTHROPIC_DEFAULT_FABLE_MODEL.

Sur les plans Pro, Max, Ultra, Team et Enterprise, un modèle claude-fable-5-1 enregistré dans vos paramètres utilisateur passe à l'alias fable :

• Plan Pro, Max ou Ultra : le changement a lieu la première fois que vous exécutez v2.1.321 ou ultérieur. Dans le terminal, la ligne de modèle de démarrage peut afficher (auto-updated) une fois.
• Plan Team ou Enterprise : le changement attend les paramètres de votre organisation ; il peut donc intervenir lors d'un démarrage ultérieur, ou ne jamais intervenir. Il s'applique à partir de la session suivante, sans ligne (auto-updated). Pour vérifier votre modèle, exécutez /model.

Après le changement, les sessions démarrent au niveau d'effort par défaut de Fable 5.2, sauf si vous avez défini un niveau pour celui-ci. Les comptes Console, les fournisseurs tiers et les paramètres de projet, locaux ou gérés conservent claude-fable-5-1.

Les requêtes que les classifieurs de sécurité d'un modèle Fable signalent, le plus souvent dans les domaines de la cybersécurité et de la biologie, déclenchent un basculement automatique vers un modèle de secours.

Pour tirer le meilleur parti de Fable :

• Décrivez le résultat, pas les étapes : donnez-lui le résultat que vous voulez et laissez-le planifier le chemin. Pour le maintenir orienté vers ce résultat, définissez un objectif.
• Donnez-lui des problèmes ambigus : les enquêtes sur les causes profondes, le débogage des pannes et les décisions architecturales sont les endroits où l'enquête et la vérification supplémentaires sont payantes.
• Ignorez les rappels de vérification : il vérifie son propre travail sans qu'on ait autant à le lui demander, donc les rappels de tester ou de vérifier sont généralement inutiles.
• Dimensionnez les tâches plus importantes : donnez-lui du travail que vous diviseriez normalement en morceaux. Il maintient de longues sessions sans perdre le fil.

[!NOTE]

Fable 5.2 nécessite Claude Code v2.1.321 ou ultérieur, et Fable 5.1 nécessite v2.1.257 ou ultérieur. Si une requête pour l'un d'eux à partir d'une version plus ancienne échoue, consultez Claude Code ne supporte pas ce modèle. Exécutez claude update pour mettre à jour. Pour la disponibilité en vertu de la rétention zéro de données, consultez Disponibilité des modèles en vertu de ZDR.

Sur l'API Anthropic, un modèle Fable apparaît dans le sélecteur /model sauf si availableModels ou les restrictions de modèle de l'organisation l'excluent. Lorsque votre organisation ne peut pas utiliser Fable du tout, par exemple en vertu de la rétention zéro de données, la ligne reste dans le sélecteur grisée, avec une note sur la raison.

Fable et crédits d'utilisation

Selon votre plan et votre niveau de siège, l'utilisation de Fable peut être facturée aux crédits d'utilisation au lieu de puiser dans les limites incluses de votre plan. Lorsque c'est le cas, le sélecteur /model affiche « Requires usage credits » sur la ligne Fable. Pour gérer les crédits d'utilisation, consultez Ajouter des crédits d'utilisation à votre abonnement.

Dans les sessions interactives, Claude Code peut afficher une invite de consentement aux crédits d'utilisation pour Fable. Vous pouvez continuer sur Fable en utilisant les crédits d'utilisation ou basculer vers votre modèle par défaut. Vous pouvez également ignorer l'invite :

• Lorsque vous sélectionnez un modèle Fable avec /model, vous conservez votre modèle actuel.
• En cours de session, Claude Code continue le tour sur votre modèle par défaut.

Après avoir choisi de continuer sur Fable en utilisant les crédits d'utilisation, Claude Code n'affiche plus l'invite.

Dans une session avec Remote Control connecté, une session en arrière-plan, ou une session d'un coéquipier d'une équipe d'agents, personne ne peut être au terminal, donc Claude Code maintient l'invite de consentement en cours de session jusqu'à la date limite dialogExpiry, cinq minutes par défaut. Si personne n'a répondu avant la date limite, Claude Code termine le tour sans envoyer la requête et ajoute un avis à la transcription, que le client Remote Control affiche également. Votre sélection de modèle est inchangée, et Claude Code demande à nouveau le consentement à votre prochain message.

Ce que vous pouvez faire pendant que l'invite attend dépend de la session :

• Avec Remote Control connecté ou dans une session d'un coéquipier, appuyez sur n'importe quelle touche au terminal pour annuler la date limite, et Claude Code attend votre réponse.
• Dans une session en arrière-plan, répondez avant la date limite.
• Si vous envoyez un nouveau message à partir du client distant avant que quelqu'un n'ait tapé au terminal, Claude Code termine le tour de la même manière, et votre nouveau message commence le tour suivant. Après que quelqu'un ait tapé au terminal, Claude Code continue d'attendre la réponse et met en file d'attente votre nouveau message derrière.

Dans une session qu'une autre application héberge via le SDK Agent, que l'invite apparaisse dépend de cette application. Si elle apparaît et que personne ne répond avant la même date limite dialogExpiry, Claude Code termine le tour sans envoyer la requête.

En mode non interactif avec le flag -p, et dans une application SDK Agent qui n'affiche pas l'invite, Claude Code ne demande jamais le consentement. Lorsqu'une requête Fable y serait facturée aux crédits d'utilisation, Claude Code la facture sans demander.

Définir votre modèle

Vous pouvez configurer votre modèle de plusieurs façons, énumérées par ordre de priorité :

1. Pendant la session : utilisez /model <alias|name> pour basculer immédiatement, ou exécutez /model sans argument pour ouvrir le sélecteur. Consultez quand Claude Code vous demande de confirmer le basculement
2. Au démarrage : lancez avec claude --model <alias|name>
3. Variable d'environnement : définissez ANTHROPIC_MODEL=<alias|name>
4. Paramètres : configurez de manière permanente dans votre fichier de paramètres en utilisant le champ model
5. Valeur par défaut pour les nouvelles sessions : définissez ANTHROPIC_DEFAULT_MODEL=<alias|name>

/model enregistre votre choix comme valeur par défaut pour les nouvelles sessions en écrivant le champ model dans vos paramètres utilisateur. Dans le sélecteur :

• Enter : basculer le modèle et enregistrer comme valeur par défaut
• s : basculer le modèle pour cette session uniquement et laisser votre valeur par défaut inchangée. Pour utiliser une touche différente, réaffectez modelPicker:thisSessionOnly

Taper /model <name> directement se comporte comme Enter. Pour basculer pour cette session uniquement, ouvrez le sélecteur avec /model et appuyez sur s sur la ligne du modèle.

Sur un plan Enterprise, lorsque vous êtes connecté avec votre compte claude.ai et que vous enregistrez une valeur par défaut avec /model, Claude Code enregistre également le choix sur ce compte. Cela nécessite Claude Code v2.1.280 ou ultérieur.

• Lorsque votre administrateur n'a pas défini un modèle par défaut de l'organisation, l'option Par défaut peut se résoudre au modèle enregistré, et lorsqu'elle le fait, la ligne Par défaut du sélecteur affiche le nom de ce modèle.
• Si les restrictions de modèle excluent le modèle enregistré ou qu'il n'est pas disponible pour votre compte, et que votre administrateur n'a pas défini un modèle par défaut de l'organisation, l'option Par défaut se résout comme si rien n'avait été enregistré.
• Si vous choisissez Par défaut ou opusplan dans /model, le choix enregistré ne change pas.

Si vous basculez les modèles avec /model, le basculement atteint également les sous-agents qui héritent du modèle de la conversation principale, car Claude Code résout leur modèle à partir de celui que votre session utilise lorsque Claude les démarre. Basculez vers Opus avant que Claude ne délègue la recherche ou les exécutions de test à l'un d'eux, et ce travail s'exécute également sur Opus. Pour garder un sous-agent personnalisé sur un modèle plus petit, définissez model dans sa définition.

Si vous définissez un modèle avec /model en mode non interactif, avec le flag -p, votre choix s'applique à la session actuelle uniquement et n'est pas enregistré comme valeur par défaut ; /model dans ce mode nécessite Claude Code v2.1.205 ou ultérieur. Les paramètres de projet et gérés conservent toujours la priorité et se réappliquent au prochain lancement. Un modèle par défaut de l'organisation que votre administrateur a configuré pour remplacer la sélection de l'utilisateur se réapplique également au prochain lancement.

Dans v2.1.144 à v2.1.152, /model s'appliquait à la session actuelle uniquement et d dans le sélecteur enregistrait une valeur par défaut.

Le flag --model et la variable d'environnement ANTHROPIC_MODEL s'appliquent uniquement à la session que vous lancez avec eux. Pour exécuter différents modèles dans différents terminaux en même temps, lancez chacun avec son propre flag --model plutôt que de basculer avec /model.

Les prix dans le sélecteur /model apparaissent lorsque Claude Code communique avec l'API Anthropic, directement ou via une passerelle LLM qui la proxifie, et le prix sur une ligne est le prix du modèle que cette ligne sélectionne. Sur les fournisseurs tiers tels qu'Amazon Bedrock et sur la passerelle d'applications Claude, votre fournisseur ou passerelle détermine ce que vous payez, donc les lignes du sélecteur n'affichent aucun prix. Le prix est une étiquette d'affichage uniquement ; il n'affecte pas le modèle qu'une ligne sélectionne ou ce que votre fournisseur facture. Avant v2.1.206, Claude Platform on AWS et les sessions de passerelle affichaient les prix de liste d'Anthropic, et une ligne pouvait afficher le prix d'un modèle différent de celui qu'elle sélectionnait.

Les sessions reprises démarrées avec claude --resume, --continue, ou le sélecteur /resume conservent le modèle qu'elles utilisaient lorsque la transcription a été enregistrée. Si le modèle restauré a été retiré ou est exclu par availableModels, la session revient à l'ordre de priorité normal. Sur les fournisseurs qui utilisent des ID de déploiement spécifiques au fournisseur plutôt que des ID de modèle Anthropic, tels qu'Amazon Bedrock, Agent Platform de Google Cloud et Microsoft Foundry, le modèle de transcription n'est pas restauré du tout et la session résout son modèle via l'ordre de priorité normal.

Si votre paramètre model est haiku, une session enregistrée sur un modèle Haiku reprend sur le modèle auquel haiku se résout désormais. Par exemple, une fois que haiku se résout à Haiku 5.5, une session enregistrée sur Haiku 4.5 reprend sur Haiku 5.5.

Un modèle que vous choisissez pour le nouveau lancement avec --model ou ANTHROPIC_MODEL conserve toujours la priorité sur le modèle restauré. À partir de v2.1.195, une variable de la famille ANTHROPIC_DEFAULT_OPUS_MODEL aussi. ANTHROPIC_DEFAULT_MODEL peut aussi, selon les conditions énumérées dans sa section.

Lorsque le modèle actif au démarrage provient des paramètres de projet ou gérés plutôt que de votre propre sélection, l'en-tête de démarrage indique quel fichier de paramètres l'a défini. Exécutez /model pour remplacer ; le paramètre de projet ou géré se réapplique au prochain lancement. Sur les plates-formes qui intègrent Claude Code et définissent CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, la configuration du modèle de l'hôte a priorité sur les paramètres de modèle gérés, tandis qu'une liste d'autorisation availableModels gérée reste en vigueur sauf si l'hôte en fournit une ; Exceptions à la priorité des paramètres gérés indique quelles clés et variables l'hôte remplace.

Si vous ou votre organisation configurez des hooks PreModelSwitch, ils s'exécutent avant qu'un basculement demandé s'applique et peuvent le bloquer ou vous demander de confirmer.

Lorsque Claude Code ne peut pas dire quels hooks PreModelSwitch vos plugins gérés de l'organisation fournissent, par exemple parce qu'un plugin géré n'a pas pu se charger, il refuse le basculement plutôt que de l'appliquer sans vérification, et il vérifie à nouveau à chaque nouvelle tentative. Consultez Le basculement de modèle a été bloqué par un hook PreModelSwitch pour le message et la récupération.

Lorsque vous basculez les modèles via la méthode setModel() du SDK Agent, via une application telle que l'application de bureau, ou à partir d'un appareil connecté via Remote Control, Claude Code vérifie la valeur au basculement :

• SDK Agent ou une application : avec Claude Code v2.1.268 ou ultérieur, sauf si Claude Code accepte un ID de modèle localement, comme il le fait pour votre option de modèle personnalisé, il confirme l'ID auprès de votre fournisseur la première fois que la session bascule vers celui-ci. La confirmation s'exécute sur chaque fournisseur, et un ID que votre fournisseur n'offre pas est refusé au basculement au lieu d'échouer à votre prochaine requête.
• Remote Control : sur l'API Anthropic, Claude Code vérifie la valeur localement et n'envoie aucune requête.

Consultez Model is not a recognized model id et Model not found pour les messages.

Si vous définissez le modèle avec le flag --model, la variable d'environnement ANTHROPIC_MODEL, ou le paramètre model, Claude Code ne rejette pas à l'avance une valeur mal orthographiée. La session démarre, et la première requête produit There's an issue with the selected model. Sur l'API Anthropic, vous pouvez voir un avertissement qui suggère le nom le plus proche si l'orthographe de la valeur est proche d'un nom ou d'un alias de modèle et qu'elle ne commence pas par claude-.

Lorsque le modèle demandé a une date de retrait programmée ou est automatiquement remappé à une version plus récente, Claude Code affiche un avertissement qui nomme le modèle demandé. Les sessions interactives l'affichent comme un avis de démarrage. À partir de v2.1.182, le même avertissement est écrit sur stderr en mode non interactif lors de l'utilisation du format de sortie texte par défaut. La vérification couvre également un model défini dans frontmatter de sous-agent. L'avertissement stderr est supprimé pour --output-format json et stream-json ; lisez le modèle réel à partir du champ modelUsage du message de résultat à la place.

Par exemple, démarrez une session sur Opus :

claude --model opus

Puis basculez les modèles depuis la session :

/model sonnet

Exemple de fichier de paramètres :

{
    "permissions": {
        "allow": ["Bash(npm run lint)"]
    },
    "model": "opus"
}

Corriger un nom de modèle mal orthographié

L'un ou l'autre de ces avertissements signifie que Claude Code ne reconnaît pas l'ID de modèle que vous avez défini, et que l'orthographe de cet ID est proche d'un nom ou d'un alias de modèle qu'il reconnaît :

⚠ Model "<model>" isn't recognized · did you mean "<suggestion>"?
Claude Code doesn't recognize the model "<model>". Did you mean "<suggestion>"?

• Vous avez mal orthographié l'ID : remplacez-le par la suggestion partout où vous définissez le modèle
• L'ID est intentionnel : laissez-le tel quel. La session l'envoie tel que vous l'avez écrit. Si la fenêtre de contexte que Claude Code suppose pour celui-ci est incorrecte, corrigez la fenêtre

Définir un modèle par défaut pour les nouvelles sessions

Définissez ANTHROPIC_DEFAULT_MODEL=<alias|name> pour choisir le modèle sur lequel vos sessions démarrent par défaut. Nécessite Claude Code v2.1.236 ou ultérieur.

Claude Code démarre une nouvelle session sur le modèle de la variable uniquement lorsqu'aucun de ces éléments ne sélectionne un modèle :

• Le flag --model
• ANTHROPIC_MODEL
• Une valeur model dans n'importe quel fichier de paramètres, y compris le choix que vous enregistrez avec /model
• Un modèle par défaut de l'organisation

Un choix que vous enregistrez avec /model a priorité sur la variable aux lancements ultérieurs aussi. Avec ANTHROPIC_MODEL défini à la place, Claude Code revient au modèle de cette variable au prochain lancement, quel que soit ce que vous avez enregistré avec /model.

Claude Code résout également l'option Par défaut au modèle de la variable, sauf si un modèle par défaut de l'organisation s'applique. Lorsque l'option Par défaut se résout au modèle de la variable, la ligne Par défaut dans le sélecteur /model affiche l'étiquette Défini par ANTHROPIC_DEFAULT_MODEL.

Claude Code ignore la variable dans ces cas, et l'option Par défaut se résout comme si vous ne l'aviez pas définie :

• Vous l'avez définie à default, inherit, opusplan, ou haiku
• enforceAvailableModels est activé
• Les restrictions de modèle de votre organisation excluent le modèle
• Le modèle n'est pas disponible pour votre compte

Lorsqu'une nouvelle session démarrerait sur le modèle de la variable, une session que vous reprenez avec claude --resume, --continue, ou le sélecteur /resume démarre également sur celui-ci. Claude Code ne restaure pas le modèle enregistré dans la transcription de cette session. Sinon, Claude Code n'utilise pas la variable lorsque vous reprenez une session.

Une nouvelle session démarre sur un modèle différent de celui que vous avez choisi

Lorsque vous choisissez un modèle avec /model et que votre prochaine session démarre sur quelque chose d'autre, ce sont les causes habituelles :

• Vous l'avez choisi pour une session. Appuyer sur s dans le sélecteur, lancer avec --model, et exécuter /model en mode non interactif s'appliquent tous à la session actuelle et laissent votre valeur par défaut enregistrée seule.
• Quelque chose avec une priorité plus élevée définit le modèle. Une valeur model dans les paramètres de projet ou gérés, ANTHROPIC_MODEL dans votre shell, ou un modèle par défaut de l'organisation que votre administrateur a défini pour remplacer les choix de l'utilisateur s'applique à nouveau à chaque lancement. Votre choix /model est toujours enregistré ; il est surclassé. Lorsque les paramètres de projet ou gérés définissent le modèle, l'en-tête de démarrage nomme le fichier.
• Claude Code n'a pas pu enregistrer votre choix. /model écrit model dans ~/.claude/settings.json. Si vous ne pouvez pas écrire dans ce fichier, par exemple parce qu'un autre outil le génère ou le lie à une copie en lecture seule, le modèle que vous avez choisi dure pour la session et le prochain lancement lit l'ancienne valeur. Définissez model dans l'outil qui génère le fichier, ou rendez le fichier inscriptible. Consultez Un changement que vous avez apporté dans Claude Code est perdu dans les nouvelles sessions.
• Vous avez repris une session. Une session que vous reprenez avec claude --resume ou --continue conserve généralement le modèle qu'elle utilisait plutôt que votre valeur par défaut actuelle.

Restreindre la sélection de modèle

Les administrateurs peuvent utiliser availableModels dans les paramètres gérés ou de politique pour restreindre les modèles que les utilisateurs peuvent sélectionner. Chaque entrée correspond à l'un des éléments suivants :

• Une famille de modèles telle que sonnet
• Un préfixe de version tel que claude-sonnet-4-5. Il correspond également aux ID de modèles ultérieurs qui l'étendent avec un autre segment. Par exemple, claude-fable-5 permet Fable 5, Fable 5.1 et Fable 5.2, tandis que claude-fable-5-1 permet uniquement Fable 5.1
• Un ID de modèle complet tel que claude-sonnet-4-5-20250929

Pour bloquer un modèle que la liste permet, ou pour faire en sorte que chaque entrée d'ID de modèle ne permette que la version qu'elle nomme, voir Bloquer des modèles ou des versions spécifiques.

Sur les plateformes qui intègrent Claude Code et définissent CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, la configuration de modèle de l'hôte a priorité sur les paramètres de modèle gérés, tandis qu'une liste d'autorisation availableModels gérée reste en vigueur sauf si l'hôte fournit la sienne ; Exceptions à la priorité des paramètres gérés indique quelles clés et variables l'hôte remplace.

Lorsque availableModels est défini, la liste d'autorisation s'applique partout où un utilisateur peut spécifier un modèle :

• Modèle de session principale : /model, l'indicateur --model, la variable d'environnement ANTHROPIC_MODEL, le paramètre model, ANTHROPIC_DEFAULT_MODEL, et le modèle restauré lors de la reprise d'une session
• Résolution d'alias : les variables d'environnement ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, et ANTHROPIC_DEFAULT_FABLE_MODEL ne peuvent pas rediriger un alias autorisé vers un modèle en dehors de la liste
• Mode rapide : /fast refuse de basculer lorsque cela changerait implicitement vers un modèle Opus en dehors de la liste, avec le message « is not in your organization's allowed models »
• Modèles de sous-agent et de coéquipier : le champ model dans la frontmatter de sous-agent, le paramètre model de l'outil Agent, les modèles de coéquipier d'équipe d'agent, CLAUDE_CODE_SUBAGENT_MODEL, et, sur v2.1.197 et antérieures, le sélecteur de modèle dans l'assistant /agents
• Modèles de compétence et de commande : la frontmatter model dans les compétences et commandes
• Modèle de conseiller : le paramètre advisorModel configuré et l'indicateur --advisor
• Modèle d'agent en arrière-plan : le modèle sélectionné dans le sélecteur de dispatch

Sur l'API Anthropic et Claude Platform on AWS, un alias de famille de modèles, opus, sonnet, haiku, ou fable, se résout à son modèle habituel lorsque la liste d'autorisation permet ce modèle. Lorsque la liste d'autorisation bloque ce modèle, Claude Code substitue la version la plus récente de la famille que la liste d'autorisation permet et affiche un avis nommant à la fois les modèles demandés et substitués. Avec ["sonnet", "claude-opus-4-6"], par exemple, à la fois /model opus et --model opus sélectionnent Claude Opus 4.6, le plus récent Opus autorisé. Avant v2.1.205, un alias dont la version la plus récente publiée était en dehors de la liste était rejeté ou remplacé comme toute autre sélection bloquée, même lorsque la liste permettait une version plus ancienne.

La substitution a besoin d'une version autorisée sur laquelle atterrir : lorsque la liste d'autorisation ne permet aucune version de la famille de l'alias, l'alias suit le comportement de rejet et de remplacement ci-dessous comme toute autre valeur bloquée.

Claude Code gère toute autre sélection bloquée selon l'endroit où le modèle a été défini :

• /model : Claude Code rejette le changement avec une erreur

• Indicateur --model, ANTHROPIC_MODEL, ou paramètre model : Claude Code remplace la valeur au démarrage par un avis nommant à la fois les modèles demandés et substitués, et la session démarre sur le modèle par défaut

• ANTHROPIC_DEFAULT_MODEL : Claude Code ignore la variable

• Remplacement de sous-agent ou de coéquipier : Claude Code exécute le sous-agent ou le coéquipier sur un modèle de secours plutôt que d'échouer la demande. Voir Choisir un modèle pour le secours du sous-agent et Spécifier les coéquipiers et les modèles pour le secours du coéquipier.

  Dans les sessions interactives, Claude Code vous avertit lorsqu'il substitue le modèle d'un sous-agent, par ce secours ou par la substitution de version la plus récente autorisée ci-dessus, nommant les modèles demandés et substitués ; il ne signale pas le secours d'un coéquipier.

  Lorsque la substitution de version la plus récente autorisée ci-dessus fonctionne, un alias de famille bloqué la suit à la place. Avant v2.1.222, un alias revenait comme toute autre valeur bloquée sur chaque fournisseur

• Remplacement de compétence ou de commande : Claude Code ignore le remplacement, y compris un alias de famille bloqué, et la compétence ou la commande s'exécute sur le modèle de session. Une compétence ou une commande qui s'exécute dans un sous-agent suit le comportement du sous-agent ci-dessus à la place

• Paramètre advisorModel : le conseiller est désactivé pour la session

• Indicateur --advisor : Claude Code se termine avec une erreur au lancement. Dans une session en arrière-plan, il démarre la session sans le conseiller au lieu de se terminer

• CLAUDE_CODE_AUTO_MODE_MODEL : Claude Code ignore la variable et choisit le modèle pour ses requêtes du classifieur du mode auto comme si vous ne l'aviez pas définie

Claude Code masque les modèles exclus du sélecteur /model. Le fait qu'un ID de modèle que vous listez obtienne également sa propre ligne dépend du fournisseur :

• API Anthropic, Claude Platform on AWS, passerelle Claude apps, ou une passerelle LLM définie via ANTHROPIC_BASE_URL : un ID de modèle Anthropic que vous listez et qui n'a pas de ligne de sélecteur intégrée apparaît comme sa propre ligne étiquetée. Claude Code ajoute une telle ligne pour les versions Opus, Sonnet et Haiku, par exemple une version plus ancienne que la liste épingle. Si vous définissez replaceBuiltInOptions dans une lineup modelPicker, cette ligne n'apparaît pas. Avant v2.1.199, un tel ID n'était sélectionnable qu'en tapant /model <id>.
• Amazon Bedrock, Agent Platform de Google Cloud ou Microsoft Foundry : sauf si un ID de modèle que vous listez commence par anthropic., Claude Code n'ajoute pas de ligne pour celui-ci, qu'il s'agisse d'un ID de modèle Anthropic ou d'un ID spécifique au fournisseur. Les ID de modèle Mantle portent ce préfixe. Pour afficher une version listée qui n'a pas de ligne intégrée, ajoutez-la également à une lineup modelPicker, qui accepte les ID au format de votre fournisseur.

Les changements de modèle que Claude Code effectue en votre nom sont vérifiés de la même manière :

• Chaînes de modèle de secours : les entrées en dehors de la liste d'autorisation sont supprimées
• Mises à niveau du mode plan : sur l'API Anthropic et Claude Platform on AWS, une mise à niveau telle que opusplan vers un modèle exclu utilise la version la plus récente autorisée de la famille de mise à niveau. Sur les fournisseurs avec des ID de modèle spécifiques au fournisseur, et lorsqu'aucune version n'est autorisée, la mise à niveau est ignorée et la planification continue sur le modèle de la session
• Secours de modèle automatique : un secours dont la cible est exclue ne s'exécute pas, donc la demande signalée se termine par un refus à la place
• Classifieur du mode auto : lorsque la liste d'autorisation exclut le modèle de classifieur par défaut, les requêtes du classifieur qui utiliseraient ce modèle s'exécutent sur le modèle de la session, ou sur un modèle Opus dans les sessions Fable. Sur les fournisseurs autres que l'API Anthropic, ce secours Opus s'exécute sur le modèle que vous définissez dans ANTHROPIC_DEFAULT_OPUS_MODEL ou, à défaut, sur Opus 5, sans consulter la liste d'autorisation. Nécessite Claude Code v2.1.210 ou ultérieur
• Mode rapide : l'activation du mode rapide est refusée lorsque le modèle sur lequel la session s'exécuterait ensuite est en dehors de la liste d'autorisation
• Secours de disponibilité sur Amazon Bedrock et Agent Platform de Google Cloud : lorsque votre compte perd l'accès à un modèle en cours de session, le basculement vers un autre modèle ignore les modèles exclus. Les vérifications de modèle au démarrage sur Amazon Bedrock et Agent Platform de Google Cloud n'ignorent les modèles exclus que lorsque les paramètres gérés définissent également enforceAvailableModels

{
  "availableModels": ["sonnet", "haiku"]
}

Couverture de surface

Chaque surface applique la liste d'autorisation qu'elle reçoit. Le mécanisme de livraison qui atteint chaque surface diffère :

• Les sessions cloud, sur Claude Code sur le web ou dans l'application de bureau, s'exécutent sur des machines virtuelles gérées par Anthropic par défaut : les paramètres déployés sur votre appareil ne les atteignent pas, donc livrez la liste d'autorisation via les paramètres gérés par le serveur. Les sessions que votre organisation achemine vers un environnement auto-hébergé s'exécutent sur votre propre calcul et lisent également le fichier de paramètres gérés dans l'image du runner. Comment Claude Code combine les sources gérées indique quand ce fichier s'applique. Un changement de modèle en milieu de session dans une session cloud est rejeté lorsque le modèle demandé est exclu par la liste d'autorisation. Lorsque la liste availableModels dans vos paramètres gérés par le serveur est non vide, le serveur rejette une demande de démarrage d'une session cloud sur un modèle que la liste exclut.
• Les sessions Claude Tag s'exécutent dans des environnements cloud mais ne reçoivent pas les paramètres gérés par le serveur ; dans un environnement auto-hébergé, elles lisent toujours le fichier de paramètres gérés dans l'image du runner. Pour définir le modèle pour ces sessions, voir Choisir le modèle pour une portée dans le guide d'administration Claude Tag.
• Cowork, l'onglet de travail agentique dans l'application Claude Desktop, exécute ses sessions sur Claude Code mais, par conception, ne reçoit pas les paramètres gérés par le serveur de la console d'administration claude.ai. Lorsque la liste availableModels dans vos paramètres gérés par le serveur est non vide et qu'un utilisateur choisit un modèle en dehors de celle-ci, le serveur rejette ce modèle pour une session Cowork distante. Un fichier de paramètres gérés s'applique aux sessions Cowork lorsqu'il est présent où la session s'exécute ; les sessions Cowork distantes s'exécutent sur des machines virtuelles gérées par Anthropic, où un fichier déployé sur l'appareil n'est pas présent.
• Les sessions sur fournisseurs tiers tels qu'Amazon Bedrock, Agent Platform de Google Cloud, Microsoft Foundry, et Claude Platform on AWS ne reçoivent pas les paramètres gérés par le serveur, donc livrez la liste d'autorisation via MDM ou des fichiers de paramètres gérés là-bas.
• La livraison depuis la console d'administration nécessite également que la session récupère les paramètres avec une connexion éligible à votre organisation ou un jeton OAuth émis pour celle-ci. Pour les flottes qui s'authentifient avec des clés API, qu'elles soient configurées directement ou générées par un script apiKeyHelper, livrez la liste d'autorisation via MDM ou des fichiers de paramètres gérés.
• L'onglet Code du bureau héberge également les sessions SSH, qui lisent le fichier de paramètres gérés à partir de l'hôte distant sur lequel elles s'exécutent. Voir Paramètres gérés du bureau.
• Les sélecteurs de modèle sur claude.ai et dans l'application de bureau masquent ou grisent les modèles exclus par la liste d'autorisation de votre organisation. L'état du sélecteur est une commodité pour les utilisateurs ; il n'applique pas la liste d'autorisation.

Comportement du modèle par défaut

Avec la correspondance de préfixe par défaut, availableModels en soi laisse l'option Par défaut sur la valeur par défaut d'exécution du système pour le compte jusqu'à ce que vous définissiez également enforceAvailableModels. Si ce défaut est un modèle que vous avez l'intention de restreindre, définissez également enforceAvailableModels, ou bloquez ce modèle.

Avec availableModels: [], les sélections de modèles nommés sont bloquées et enforceAvailableModels n'a aucun effet.

Appliquer la liste d'autorisation au modèle par défaut

Définissez enforceAvailableModels: true aux côtés d'un availableModels non vide dans les paramètres gérés pour étendre la liste d'autorisation à l'option Par défaut. Cela nécessite Claude Code v2.1.175 ou ultérieur.

{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}

Pour un membre sans modèle enregistré sur son compte, l'option Par défaut se résout au défaut du type de compte, ou au modèle par défaut d'organisation lorsqu'un administrateur en a défini un. Lorsque ce modèle n'est pas dans la liste d'autorisation, l'option Par défaut se résout à la place à la première entrée availableModels qui nomme un modèle autorisé et disponible, et la ligne Par défaut du sélecteur /model affiche ce modèle. Cela s'applique partout où le défaut est atteint : démarrage de session, sélection de Par défaut dans /model, le mot-clé "default" dans les chaînes de modèle de secours, et le secours utilisé lorsqu'une sélection exclue est supprimée. Un modèle enregistré sur le compte d'un membre est également vérifié par rapport à availableModels ; Définir votre modèle décrit comment l'option Par défaut le traite.

enforceAvailableModels remapte l'option Par défaut uniquement lorsque availableModels est non vide. Lorsque availableModels est non vide mais qu'aucune entrée ne se résout à un modèle autorisé et disponible, l'application est ignorée avec un avertissement visible uniquement sous --debug. Gardez au moins une entrée garantie disponible dans la liste pour éviter cela.

Déployez les deux clés ensemble dans la source gérée la mieux classée que vous livrez. Par défaut, Claude Code ne lit que cette source, donc une paire placée dans un fichier de paramètres gérés est ignorée lorsque la console d'administration livre des paramètres ; sous la fusion opt-in dans comment Claude Code combine les sources gérées, Claude Code ignore toujours une carte modelOverrides d'une source classée en dessous de celle qui définit availableModels.

Contrôler le modèle sur lequel les utilisateurs s'exécutent

Le paramètre model est une sélection initiale, pas une application. Il définit quel modèle est actif au démarrage d'une session, mais les utilisateurs peuvent toujours ouvrir /model et choisir Par défaut, qui se résout à la valeur par défaut d'exécution du système quel que soit ce qui est défini pour model, sauf si enforceAvailableModels ou les clés qui bloquent des versions spécifiques s'appliquent à cela.

Pour contrôler complètement l'expérience du modèle, combinez ces paramètres :

• availableModels : restreint les modèles nommés vers lesquels les utilisateurs peuvent basculer
• enforceAvailableModels : étend la liste d'autorisation availableModels à l'option Par défaut, donc Par défaut ne peut pas se résoudre à un modèle en dehors de la liste
• deniedModels et availableModelsMatch : bloquez des versions spécifiques qu'une entrée availableModels permettrait autrement
• model : définit la sélection de modèle initiale au démarrage d'une session
• ANTHROPIC_DEFAULT_SONNET_MODEL / ANTHROPIC_DEFAULT_OPUS_MODEL / ANTHROPIC_DEFAULT_HAIKU_MODEL / ANTHROPIC_DEFAULT_FABLE_MODEL : contrôlez à quoi les alias sonnet, opus, haiku, et fable se résolvent, et quelle version la valeur par défaut du type de compte utilise

Cet exemple démarre les utilisateurs sur Sonnet 4.5, limite le sélecteur à Sonnet et Haiku, et garantit que Par défaut se résout à un modèle sur la liste d'autorisation plutôt que la valeur par défaut du niveau :

{
  "model": "claude-sonnet-4-5",
  "availableModels": ["claude-sonnet-4-5", "haiku"],
  "enforceAvailableModels": true,
  "env": {
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5"
  }
}

Sans enforceAvailableModels ou le bloc env, un utilisateur qui sélectionne Par défaut dans le sélecteur obtient la valeur par défaut d'exécution plutôt que la version épinglée dans model. Les deux paramètres couvrent des portées différentes : enforceAvailableModels fait que Par défaut obéit à la liste d'autorisation, tandis que le bloc env épingle quelle version un alias autorisé tel que sonnet se résout. Utilisez enforceAvailableModels seul lorsque restreindre les familles de modèles est suffisant ; ajoutez le bloc env lorsque vous avez également besoin d'épingler une version spécifique.

Comportement de fusion

Lorsque les paramètres gérés que Claude Code applique définissent availableModels, cette liste seule s'applique, à part une plateforme hôte qui fournit la sienne : les entrées dans les paramètres utilisateur, projet ou local ne peuvent pas l'étendre, et Claude Code ne fusionne jamais availableModels entre les sources gérées non plus ; comment Claude Code combine les sources gérées indique quelle liste de source s'applique. Sinon, les listes des paramètres utilisateur, projet et local sont concaténées et dédupliquées comme d'autres paramètres de tableau. Avant Claude Code v2.1.175, les entrées des portées de priorité inférieure fusionnaient dans la liste gérée au lieu d'être remplacées par elle.

Dans la liste effective, une entrée nommant un modèle spécifique dans une famille, qu'il s'agisse d'un préfixe de version ou d'un ID de modèle complet, désactive l'entrée de caractère générique de cette famille. Par exemple, avec ["sonnet", "claude-sonnet-4-5"], les utilisateurs ne peuvent choisir que les ID de modèle auxquels claude-sonnet-4-5 correspond, et non tous les modèles Sonnet.

ID de modèle Mantle

Les entrées dans availableModels qui commencent par anthropic. sont ajoutées au sélecteur /model comme options personnalisées. Ceci est une exception à la correspondance d'alias décrite dans Épingler les modèles pour les déploiements tiers. Lorsque l'endpoint Amazon Bedrock Mantle est activé, Claude Code achemine les entrées qui correspondent au format Mantle vers cet endpoint. Le paramètre restreint toujours le sélecteur aux entrées listées, et un ID Mantle intègre un nom de famille, donc il compte comme une entrée spécifique et désactive le caractère générique de cette famille : aux côtés de tous les ID Mantle, listez les préfixes de version ou les ID complets que vous souhaitez garder sélectionnables. Voir Comportement de fusion.

Bloquer des modèles ou des versions spécifiques

Une entrée availableModels telle que claude-opus-5 permet également les versions ultérieures qui l'étendent, telles qu'Opus 5.5, dès que Claude Code les supporte. Deux paramètres gérés vous permettent de retenir une version, et les deux nécessitent Claude Code v2.1.283 ou ultérieur :

• deniedModels : listez les modèles à bloquer. Un modèle listé est bloqué même lorsque availableModels le permet, et la clé fonctionne également sans liste d'autorisation du tout. Une version qu'aucune entrée ne bloque reste autorisée
• availableModelsMatch : définissez-le sur "exact" pour que chaque ID de modèle dans availableModels ne permette que la version qu'il nomme. Une version plus récente d'un ID de modèle listé reste alors bloquée jusqu'à ce que vous l'ajoutiez à la liste

Les versions antérieures ignorent les deux clés, donc définissez également requiredMinimumVersion pour empêcher ces versions de démarrer.

Cet exemple permet les modèles Opus et Sonnet et bloque Opus 5.5 dans chaque orthographe, y compris les ID datés et spécifiques au fournisseur :

{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}

Un modèle bloqué, qu'il soit nommé par deniedModels ou omis par une liste "exact", est traité comme une sélection bloquée partout où la liste d'autorisation s'applique. Il est masqué du sélecteur /model, et /model <name> le rejette. Si vous nommez un ID de modèle bloqué avec --model, ANTHROPIC_MODEL, ou le paramètre model, Claude Code le supprime au démarrage et résout l'option Par défaut à la place. Si un hook ou une demande en arrière-plan nomme un modèle que deniedModels bloque, tel qu'un champ model de hook d'agent, cette demande s'exécute sur le modèle de la session à la place.

L'option Par défaut suit les deux clés également, que vous définissiez ou non enforceAvailableModels. Si vous le définissez avec un availableModels non vide, un défaut bloqué compte comme un modèle en dehors de la liste d'autorisation. Sinon, une option Par défaut qui se résoudrait à un modèle bloqué descend dans cet ordre :

1. La version la plus récente autorisée de la même famille
2. Le modèle autorisé le plus récent de chaque famille de coût inférieur à tour de rôle : Sonnet, puis Haiku
3. La première entrée availableModels qui nomme un modèle autorisé

Si aucun de ceux-ci n'est autorisé, une session démarrée sur l'option Par défaut refuse de démarrer avec une erreur qui nomme la clé à corriger. Une liste "exact" affecte l'option Par défaut uniquement lorsque la liste availableModels gérée nomme au moins un modèle ou une famille.

Claude Code lit les deux clés à partir des paramètres gérés uniquement. Si vous définissez l'une ou l'autre dans les paramètres utilisateur, projet ou local ou avec --settings, Claude Code l'ignore avec un avertissement.

Restrictions de modèle d'organisation

Les administrateurs d'organisation sur les plans Claude Enterprise restreignent les modèles que les membres peuvent exécuter en désactivant les modèles individuels dans la console d'administration claude.ai. Cette restriction est livrée avec les droits du compte lorsque Claude Code s'authentifie, séparé de toute liste availableModels dans les paramètres, et le serveur applique la même restriction indépendamment lorsqu'une session est créée. Nécessite Claude Code v2.1.187 ou ultérieur.

La restriction s'applique lorsqu'un membre se connecte ou utilise sa propre clé API. Les identifiants d'organisation, tels que les clés de service d'organisation, ne sont pas liés à un utilisateur, donc la restriction ne s'applique pas à eux.

La console Claude n'a pas de contrôle de restriction de modèle. Les organisations sans plan Claude Enterprise, y compris celles dont les membres s'authentifient via l'API Anthropic, restreignent les modèles avec availableModels dans les paramètres gérés à la place, en ajoutant enforceAvailableModels pour couvrir l'option Par défaut. Couverture de surface indique comment chaque surface reçoit et applique ces paramètres.

Un modèle restreint est masqué du sélecteur /model. Le sélectionner par nom avec --model, la variable d'environnement ANTHROPIC_MODEL, ou le paramètre model affiche l'avis Model "<name>" is restricted by your organization's settings. Using <model> instead. et la session démarre sur un modèle autorisé. Taper /model <name> pour un modèle restreint est rejeté avec Model '<name>' is restricted by your organization's settings. Run /model to choose a different model. et la session garde son modèle actuel.

Un alias de famille de modèles tel que opus se résout à son modèle habituel lorsque l'organisation le permet. Lorsque l'organisation restreint ce modèle, Claude Code substitue la version la plus récente de la famille que l'organisation permet, avec le même avis de substitution. /model <alias> est rejeté uniquement lorsque chaque version de sa famille est restreinte ; un alias défini avec --model, ANTHROPIC_MODEL, ou le paramètre model est toujours remplacé au démarrage dans ce cas. Avant v2.1.205, un alias de famille était substitué ou rejeté en fonction de sa version la plus récente publiée seule, même lorsqu'une version plus ancienne était autorisée.

Les restrictions s'appliquent à l'échelle de l'organisation ou par rôle :

• La désactivation d'un modèle au niveau de l'organisation le supprime pour chaque membre.
• L'accès au niveau du rôle accorde différents modèles à différents rôles personnalisés, et un membre qui détient plusieurs rôles peut utiliser n'importe quel modèle qu'un de ses rôles accorde.
• Les modèles Haiku sont toujours disponibles et ne peuvent pas être désactivés, donc chaque membre garde au moins un modèle utilisable.
• Un changement d'accès prend effet sur les nouvelles demandes dans environ une minute ; le sélecteur /model le reflète la prochaine fois qu'une session démarre.

Les deux restrictions s'appliquent ensemble : un modèle n'est sélectionnable que lorsqu'il est autorisé par availableModels et non restreint par l'organisation. Les restrictions d'organisation atteignent les sessions sur l'API Anthropic et les déploiements de passerelle LLM uniquement ; sur tout autre fournisseur, utilisez availableModels à la place.

Modèle par défaut de l'organisation

Les administrateurs d'organisation sur les plans Claude Enterprise peuvent définir un modèle par défaut pour les membres de Claude Code à partir de la console d'administration claude.ai, pour l'ensemble de l'organisation ou par rôle personnalisé. Lorsqu'un modèle est défini, l'option Par défaut se résout à ce modèle. Nécessite Claude Code v2.1.196 ou version ultérieure.

La ligne Par défaut dans le sélecteur /model affiche le nom du modèle par défaut de l'organisation avec l'étiquette Org default. L'étiquette indique Org default que l'administrateur ait défini le modèle par défaut pour l'ensemble de l'organisation ou pour votre rôle. Un modèle par défaut de rôle s'applique aux membres de ce rôle personnalisé et prend précédence sur le modèle par défaut à l'échelle de l'organisation ; lorsque plusieurs de vos rôles définissent des modèles par défaut différents, le modèle le plus capable s'applique.

Le modèle par défaut de l'organisation est un point de départ, pas une restriction. Ces sélections prennent précédence sur celui-ci :

• le drapeau --model et la variable d'environnement ANTHROPIC_MODEL
• une valeur model dans les paramètres gérés ou fournie via --settings
• une valeur model dans vos paramètres utilisateur, projet ou locaux, y compris un modèle que vous enregistrez avec /model

Les administrateurs peuvent également configurer le modèle par défaut de l'organisation pour remplacer la sélection de l'utilisateur. Avec le remplacement activé, il a priorité sur la valeur model dans les paramètres utilisateur, projet et locaux, de sorte qu'un modèle que vous enregistrez avec /model s'applique pour la session actuelle et le modèle par défaut de l'organisation revient au lancement suivant. Lorsque votre sélection diffère, /model affiche Your organization's default (<model>) applies on restart. Le flag --model, ANTHROPIC_MODEL, les paramètres gérés et --settings ont toujours priorité même avec le remplacement activé.

Pour limiter les modèles que les membres peuvent sélectionner, utilisez plutôt les restrictions de modèle de l'organisation ou availableModels.

Claude Code lit le modèle par défaut de l'organisation une seule fois au démarrage, de sorte qu'un modèle par défaut que l'administrateur modifie en cours de session prend effet au lancement suivant.

Lorsque le modèle par défaut de l'organisation ne remplace pas la sélection de l'utilisateur, le premier lancement interactif après que l'administrateur le modifie efface la clé model de vos paramètres utilisateur une seule fois, de sorte que le nouveau modèle par défaut s'applique. Il ne change rien d'autre dans le fichier, et un modèle que vous enregistrez avec /model après ce lancement est conservé.

Le modèle par défaut de l'organisation passe par ces vérifications de restriction avant d'être adopté :

• Avec la correspondance du préfixe par défaut, availableModels seul ne s'applique pas au modèle par défaut de l'organisation, de sorte qu'un modèle par défaut de l'organisation en dehors de la liste d'autorisation s'applique toujours. Lorsque enforceAvailableModels est également défini, un modèle par défaut de l'organisation en dehors de la liste d'autorisation est remappé à la première entrée de la liste d'autorisation, comme tout autre modèle Par défaut
• un modèle par défaut de l'organisation que les restrictions de modèle de l'organisation refusent pour votre compte est remplacé par le modèle le plus récent autorisé dans sa famille, ou une famille moins coûteuse lorsque chaque version de celle-ci est restreinte
• pour un modèle par défaut de l'organisation que deniedModels ou une liste "exact" bloque, voir Bloquer des modèles ou des versions spécifiques
• un modèle par défaut de l'organisation qui n'est pas disponible pour votre compte du tout est ignoré, et l'option Par défaut se résout comme elle le ferait sans modèle par défaut de l'organisation

À partir de la v2.1.199, lorsque le modèle par défaut de l'organisation est une famille de modèles différente du modèle par défaut habituel du type de votre compte, le sélecteur /model conserve une ligne séparée pour cette famille habituelle, de sorte que vous pouvez toujours basculer vers celle-ci pour une session. Dans les versions v2.1.196 à v2.1.198, cette ligne est absente du sélecteur.

Le modèle par défaut de l'organisation ne s'applique qu'aux sessions authentifiées avec l'API Anthropic. Pour définir un modèle par défaut ailleurs, y compris dans les déploiements de passerelle LLM, utilisez plutôt la clé model dans les paramètres gérés.

Limites d'effort au niveau de l'organisation

Votre organisation peut plafonner le niveau d'effort de deux façons. Sur un plan Claude Enterprise, les administrateurs d'organisation définissent des limites d'effort par rôle, décrites ci-dessous. Sur n'importe quel plan et n'importe quel fournisseur, y compris Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry, le paramètre géré maxEffortLevel plafonne l'effort côté client. Lorsque les deux s'appliquent à un modèle, le plafond inférieur s'applique.

Les administrateurs d'organisation sur les plans Claude Enterprise peuvent définir un niveau d'effort maximum par modèle pour chaque rôle personnalisé, aux côtés des restrictions de modèle au niveau de l'organisation. Nécessite Claude Code v2.1.195 ou version ultérieure.

• Les niveaux au-dessus du plafond ne sont pas proposés dans le sélecteur /effort, et nommer un niveau supérieur avec --effort ou /effort s'exécute au plafond à la place. Si vous lancez une exécution en texte brut --print avec --effort au-dessus du plafond, un avertissement sur stderr nomme les niveaux demandés et appliqués. Dans les sessions interactives, avec une sortie json ou stream-json, ou dans les agents en arrière-plan, cet avertissement est envoyé dans le log de débogage à la place.
• Les plafonds sont par modèle, donc changer de modèle peut modifier les niveaux disponibles.
• Lorsque plusieurs de vos rôles accordent le même modèle, le plafond le moins restrictif s'applique.

Les limites d'effort sont livrées avec les restrictions de modèle au niveau de l'organisation et atteignent les mêmes sessions.

Comportement particulier des modèles

Paramètre de modèle default

Le comportement de default dépend de votre type de compte :

• Pro, Max, Ultra, Team, Enterprise et API Anthropic : Opus 5.5 par défaut
• Claude Platform on AWS, Amazon Bedrock et Google Cloud's Agent Platform : Opus 5.5 par défaut
• Microsoft Foundry : Sonnet 4.5 par défaut

Avant la v2.1.280, default correspondait à Sonnet 5 sur Pro et Team Standard, et à Opus 5 sur Max, Ultra, Team Premium, Enterprise, l'API Anthropic, Claude Platform on AWS, Amazon Bedrock et Google Cloud's Agent Platform à partir de la v2.1.219. Avant la v2.1.219, default correspondait à Opus 4.8 sur l'API Anthropic, Max, Ultra, Team Premium et Enterprise à l'usage à partir de la v2.1.154, et sur Claude Platform on AWS, Amazon Bedrock et Google Cloud's Agent Platform à partir de la v2.1.207. Avant la v2.1.207, default correspondait à Opus 4.7 sur Claude Platform on AWS et à Sonnet 4.5 sur Amazon Bedrock et Google Cloud's Agent Platform.

Lorsqu'un administrateur a défini un modèle par défaut de l'organisation, default correspond à ce modèle plutôt qu'au modèle par défaut du type de compte indiqué ci-dessus. Nécessite Claude Code v2.1.196 ou une version ultérieure. default peut également correspondre au modèle que vous définissez avec ANTHROPIC_DEFAULT_MODEL, dans les conditions indiquées dans sa section, ou au modèle enregistré sur votre compte.

Lorsque rien n'est enregistré sur votre compte, que les paramètres gérés imposent la liste d'autorisation pour le modèle Default et que le modèle par défaut du type de compte ne figure pas dans availableModels, default correspond au Default imposé plutôt qu'au modèle par défaut du type de compte indiqué ci-dessus. Lorsqu'un modèle par défaut de l'organisation et l'application de la liste s'appliquent tous les deux, le modèle par défaut de l'organisation remplace d'abord le modèle par défaut du type de compte, puis l'application de la liste s'y applique : un modèle par défaut de l'organisation figurant dans la liste d'autorisation est conservé, tandis qu'un modèle hors de la liste correspond au Default imposé.

[!NOTE]

Les modèles Fable ne sont le modèle par défaut du type de compte sur aucun forfait ni fournisseur. En choisir un avec /model l'enregistre comme modèle sélectionné dans vos paramètres utilisateur, de sorte que les sessions suivantes démarrent avec lui, à l'exception de la modification ponctuelle apportée à une sélection Fable 5.1 enregistrée.

Paramètre de modèle opusplan

L'alias de modèle opusplan offre une approche hybride automatisée :

• En mode plan : utilise opus pour le raisonnement complexe et les décisions d'architecture
• En mode exécution : bascule automatiquement vers sonnet pour la génération de code et l'implémentation

Vous associez ainsi le raisonnement d'Opus pour la planification à l'efficacité de Sonnet pour l'exécution.

La phase Opus du mode plan utilise la même fenêtre de contexte que le paramètre de modèle opus, et la phase d'exécution utilise la même fenêtre que sonnet. Lorsque opus et sonnet correspondent à des modèles qui fonctionnent par défaut avec la fenêtre de contexte de 1M, comme c'est le cas des modèles actuels sur l'API Anthropic, les deux phases l'utilisent. Pour demander un contexte de 1M pour les deux phases lorsque ce n'est pas le cas, définissez le modèle sur opusplan[1m], par exemple avec /model opusplan[1m]. Le définir avec /model nécessite Claude Code v2.1.265 ou une version ultérieure ; sur les versions antérieures, utilisez plutôt le flag --model ou le paramètre model.

Lorsque availableModels exclut le modèle Opus le plus récent mais autorise une version plus ancienne, par exemple ["sonnet", "claude-opus-4-6"], opusplan utilise le modèle Opus autorisé le plus récent pour la planification et ne reste sur Sonnet que lorsque tous les modèles Opus sont exclus. De même, une session Haiku qui passerait normalement à Sonnet en mode plan utilise le modèle Sonnet autorisé le plus récent, et ne reste sur Haiku que lorsque tous les modèles Sonnet sont exclus. Avant la v2.1.205, le mode plan restait sur le modèle de la session dès que la version la plus récente de la famille cible était exclue, même lorsque la liste d'autorisation permettait une version plus ancienne.

La substitution par une version plus ancienne autorisée s'applique sur l'API Anthropic et sur Claude Platform on AWS. Sur Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry et Mantle, dont les déploiements utilisent des identifiants de modèle propres au fournisseur, le mode plan reste sur le modèle de la session dès que le modèle cible est exclu.

Pour une approche hybride dans laquelle Claude décide en cours de tâche quand consulter un second modèle plutôt que de basculer à la frontière du plan, consultez l'outil advisor.

Chaînes de modèles de secours

Lorsque le modèle principal est surchargé, indisponible ou renvoie une autre erreur serveur non réessayable, Claude Code peut basculer sur un modèle de secours au lieu de faire échouer la requête. Les erreurs d'authentification, de facturation, de limite de débit, de taille de requête et de transport, ainsi qu'un refus par la vérification des politiques de votre organisation, ne déclenchent jamais de bascule ; elles suivent leur gestion habituelle des nouvelles tentatives et des erreurs. La bascule a bien lieu lorsque Amazon Bedrock ou Google Cloud's Agent Platform refuse un modèle que votre compte ne peut pas invoquer, ce que Claude Code traite comme une indisponibilité du modèle plutôt que comme une erreur d'authentification.

Configurez un ou plusieurs modèles de secours et Claude Code les essaie dans l'ordre, en affichant un avis lorsqu'il bascule. La bascule ne dure que pour le tour en cours : votre message suivant essaie de nouveau le modèle principal en premier. Claude Code limite les chaînes à trois modèles après suppression des doublons et ignore les entrées supplémentaires.

Définissez une chaîne pour une session avec le flag --fallback-model, qui accepte une liste séparée par des virgules :

claude --fallback-model sonnet,haiku

Pour conserver une chaîne d'une session à l'autre, définissez fallbackModel dans les paramètres sous forme de tableau :

{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

Le flag --fallback-model a priorité sur le paramètre fallbackModel. Chaque entrée accepte un nom ou un alias de modèle, et "default" correspond au modèle par défaut.

Claude Code ne confirme pas la chaîne au démarrage et /status ne l'affiche pas. L'avis affiché lors d'une bascule est le premier signe visible qu'un modèle de secours est configuré.

Lorsqu'une requête bascule, Claude Code essaie chaque entrée dans l'ordre jusqu'à ce que l'une d'elles l'accepte. Une entrée également injoignable, comme un modèle retiré épinglé dans les paramètres, bascule de la même manière sur la suivante. Claude Code supprime deux types d'entrées avant de commencer ce parcours :

• Hors de la liste d'autorisation : Claude Code écarte toute entrée non autorisée par availableModels lorsqu'il lit la chaîne.
• Fenêtre de contexte plus petite pendant la compaction : la chaîne couvre aussi la compaction, mais Claude Code ne se rabat pas sur un modèle dont la fenêtre de contexte est plus petite que celle du modèle principal, car y résumer la conversation en tronquerait d'abord une partie. Si tous les modèles de secours sont plus petits, la compaction affiche l'erreur d'origine et vous pouvez réessayer.

Claude Code applique également la chaîne aux sous-agents. Lorsqu'une requête d'un sous-agent bascule, Claude Code essaie vos modèles de secours configurés dans l'ordre, et le sous-agent continue avec le modèle qui accepte la requête. Le modèle de votre session reste inchangé. Avant la v2.1.247, un échec couvert par la chaîne mettait plutôt fin au sous-agent.

Bascule automatique de modèle

Cette section traite de la bascule fondée sur le contenu depuis les modèles Fable, Opus 5.5, Sonnet 5.5 et Opus 5. Pour la bascule fondée sur la disponibilité lorsqu'un modèle est surchargé ou indisponible, consultez Chaînes de modèles de secours.

Les modèles Fable, Opus 5.5, Sonnet 5.5 et Opus 5 fonctionnent avec des classifieurs de sécurité, qui signalent le plus souvent des contenus liés à la cybersécurité et à la biologie. Pour ces deux catégories, le modèle de secours dépend du modèle qui a refusé :

• Modèles Fable et Opus 5.5 : les requêtes signalées pour la biologie sont réexécutées sur Opus 5, et celles signalées pour la cybersécurité sur Opus 4.8.
• Sonnet 5.5 : les requêtes signalées pour la cybersécurité sont réexécutées sur Sonnet 5. Les requêtes signalées pour la biologie se terminent plutôt par un refus, car Sonnet 5.5 n'a pas de modèle de secours pour la biologie.
• Opus 5 : les requêtes signalées pour la cybersécurité sont réexécutées sur Opus 4.8. Les requêtes signalées pour la biologie se terminent plutôt par un refus, car Opus 5 exécute ses propres classifieurs de biologie sans modèle de secours.

Sur Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry, Claude Code résout plutôt ces cibles à partir des identifiants de modèle de votre déploiement. Consultez Activer la bascule sur Bedrock, Agent Platform et Foundry.

Lorsque Claude Code bascule une requête signalée vers le modèle de secours de sa catégorie, il réexécute la requête sur ce modèle. Dans votre conversation principale, il affiche un avis dans la transcription. Pour qu'on vous demande d'abord votre avis, consultez Demander avant de basculer.

Après une bascule, la session continue sur le modèle de secours. Pour revenir à votre modèle d'origine, exécutez /model.

La bascule par catégorie nécessite Claude Code v2.1.219 ou une version ultérieure. Avant la v2.1.219, chaque requête Fable 5 signalée était réexécutée sur le modèle Opus par défaut de votre fournisseur, et Opus 5 n'était pas un modèle source de bascule.

Le modèle de secours est vérifié par rapport à availableModels. Lorsqu'il est bloqué, aucune bascule n'a lieu. Le refus s'affiche comme une erreur normale et le modèle de la session reste inchangé.

Niveau d'effort après une bascule

Lorsque Claude Code bascule votre session sur le modèle de secours, il conserve le niveau d'effort auquel la requête signalée s'exécutait. Par exemple, une session sur Opus 5.5 à son niveau medium par défaut qui bascule sur Opus 4.8 reste à medium, bien qu'Opus 4.8 soit à high par défaut.

Un autre niveau s'applique dans des cas comme ceux-ci :

• Votre propre modification : dès que vous choisissez un niveau d'effort, sélectionnez un modèle dans /model ou reprenez la session plus tard, le niveau de la requête signalée n'est plus reporté.
• Effort défini pour un seul tour : si vous avez augmenté le tour signalé avec ultrathink, ou si le frontmatter effort d'un skill a défini son niveau, ce niveau s'applique à ce tour. Les tours suivants s'exécutent au niveau que l'ordre de résolution de l'effort attribue au modèle de secours.

Pour voir le niveau défini pour votre session après une bascule, exécutez /effort status. Pour le modifier, exécutez /effort.

Vérifier ce qui a déclenché la bascule

La bascule peut se déclencher dès la première requête d'une session, avant que vous n'envoyiez quoi que ce soit d'inhabituel, car la première requête transporte le contexte de l'espace de travail, comme le contenu de votre CLAUDE.md et le statut git. Un dépôt contenant des éléments liés à la sécurité ou à la biologie peut déclencher le classifieur sur ce seul contexte.

Pour vérifier si des personnalisations sont en cause, démarrez une session avec claude --safe-mode, qui désactive les personnalisations comme CLAUDE.md, les skills, les serveurs MCP et les hooks. Le statut git et les noms de répertoires ne sont pas des personnalisations et restent inclus.

Demander avant de basculer

Pour décider de ce qui se passe chaque fois qu'une requête est signalée, exécutez /config, sélectionnez Switch models when a message is flagged et choisissez Ask each time. Vous pouvez aussi définir switchModelsOnFlag sur false dans votre fichier de paramètres. Claude Code s'arrête alors sur une requête signalée qui changerait de modèle et vous propose deux options : basculer vers le modèle de secours, ou modifier le prompt et réessayer.

La première fois qu'une requête signalée changerait de modèle dans une session interactive, Claude Code peut vous demander s'il doit désormais basculer automatiquement. Il ne le demande que si vous n'avez pas défini switchModelsOnFlag, et il enregistre votre choix sous cette clé dans vos paramètres utilisateur.

Si vous choisissez plutôt de rester sur le modèle actuel, la valeur enregistrée est false, comme pour Ask each time. Si vous ignorez la question, Claude Code n'enregistre rien et la pose de nouveau la prochaine fois qu'une requête signalée changerait de modèle.

Lorsque vous avez choisi Ask each time, certains cas se comportent différemment :

• Lorsque la catégorie signalée n'a pas de modèle de secours, comme un signalement pour la biologie sur Opus 5 ou Sonnet 5.5, Claude Code n'affiche pas la demande et la requête se termine par le refus.
• Si les deux modèles signalent la même requête, vous pouvez modifier le prompt et réessayer, ou démarrer une nouvelle session.
• Dans les sessions cloud sur l'application mobile, la modification et la nouvelle tentative ne sont pas prises en charge. Changez de modèle, ou poursuivez la session depuis un navigateur de bureau ou l'application de bureau.
• En mode non interactif et dans les intégrations SDK qui ne peuvent pas afficher la demande, une requête signalée termine plutôt le tour par un refus.
• Dans un sous-agent que Claude démarre avec l'outil Agent, Claude Code ne s'arrête pas pour demander, et le sous-agent échoue au lieu de changer de modèle. Consultez Les sous-agents basculent ou échouent sans demander.
• Lorsque la cible de secours est bloquée par availableModels, Claude Code n'affiche pas la demande. La requête signalée se termine par le refus, comme pour la bascule automatique lorsque la cible est bloquée.

Les sous-agents basculent ou échouent sans demander

Dans un sous-agent intégré ou personnalisé que Claude démarre avec l'outil Agent, Claude Code ne s'arrête pas pour demander sur une requête signalée. Si un modèle de secours est disponible, la requête est réexécutée sur celui-ci ou le sous-agent échoue, selon votre choix pour Switch models when a message is flagged dans /config :

• Switch automatically, ou aucun choix effectué : la requête est réexécutée sur le modèle de secours, et le modèle de votre session reste inchangé
• Ask each time : le sous-agent échoue avec Agent terminated early due to an API error et le message de refus. Claude reçoit cette erreur et décide de la suite à donner à la tâche inachevée. Pour permettre aux sous-agents de changer de modèle, choisissez Switch automatically. Votre conversation principale bascule alors elle aussi sans demander.

Lorsqu'aucun modèle de secours n'est disponible, le sous-agent échoue de la même manière quel que soit votre choix. Avant la v2.1.318, la requête signalée d'un sous-agent était réexécutée sur un modèle de secours disponible, quel que soit votre choix.

Activer la bascule sur Bedrock, Agent Platform et Foundry

Sur Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry, les identifiants de modèle sont propres au fournisseur ; la bascule automatique ne fonctionne donc que lorsque Claude Code peut identifier chaque modèle concerné :

• Claude Code doit reconnaître le modèle actuel comme modèle source de bascule. Les modèles Fable sont reconnus lorsque l'identifiant du modèle contient claude-fable-5, correspond à la valeur de ANTHROPIC_DEFAULT_FABLE_MODEL, ou est mappé avec modelOverrides. Opus 5.5, Sonnet 5.5 et Opus 5 sont reconnus par leur identifiant de modèle chez le fournisseur ou par un mappage modelOverrides.
• Une cible Opus doit être résolue dans votre déploiement, quel que soit le modèle qui a refusé : définissez ANTHROPIC_DEFAULT_OPUS_MODEL, ou conservez une entrée Opus 4.8 dans la liste des modèles du fournisseur. Sans cela, la bascule reste désactivée pour tous les modèles sources, y compris Sonnet 5.5, et les requêtes signalées se terminent par un refus.
• Le modèle de secours de la catégorie signalée doit être résolu dans votre déploiement. Depuis un modèle Fable, Opus 5.5 ou Opus 5, si vous définissez ANTHROPIC_DEFAULT_OPUS_MODEL, les requêtes signalées sont réexécutées sur ce modèle pour chaque catégorie disposant d'un modèle de secours ; un signalement pour la biologie sur Opus 5 se termine toujours par un refus. Si vous ne le définissez pas, les requêtes signalées pour la cybersécurité sont réexécutées sur l'entrée Opus 4.8, et les requêtes signalées pour la biologie depuis un modèle Fable ou Opus 5.5 sur une entrée Opus 5. Depuis Sonnet 5.5, les requêtes signalées pour la cybersécurité sont réexécutées sur le modèle que vous définissez dans ANTHROPIC_DEFAULT_SONNET_MODEL, ou sur une entrée Sonnet 5 de la liste des modèles du fournisseur si vous ne le définissez pas.

Si l'un des deux modèles ne peut pas être identifié, Claude Code ne bascule pas. La requête signalée se termine par un message de refus, et vous pouvez changer de modèle avec /model et réessayer. Pour rendre les deux modèles identifiables, définissez les épinglages correspondant à votre modèle source :

• Modèles Fable : définissez ANTHROPIC_DEFAULT_FABLE_MODEL sur l'identifiant de votre modèle Fable afin que Claude Code le reconnaisse comme modèle source de bascule.
• Tous les modèles sources : définissez ANTHROPIC_DEFAULT_OPUS_MODEL sur un identifiant de modèle Opus pour activer la bascule et donner une cible aux catégories signalées. Un épinglage qui désigne un modèle hors de la famille Opus, ou le modèle qui a refusé, laisse le refus en place.
• Sonnet 5.5 : en plus de l'épinglage Opus, définissez ANTHROPIC_DEFAULT_SONNET_MODEL ou conservez une entrée Sonnet 5 dans la liste des modèles du fournisseur pour fournir le modèle sur lequel la requête est réexécutée. Un épinglage Sonnet qui désigne un modèle hors de la famille Sonnet, ou Sonnet 5.5 lui-même, laisse le refus en place.

Le modèle de secours doit également disposer d'une fenêtre de contexte au moins aussi grande que celle de la session ; sinon, Claude Code ne bascule pas et la requête signalée se termine par le même refus. Sur ces fournisseurs, les modèles sources fonctionnent par défaut avec la fenêtre de contexte de 1M. Épinglez un modèle qui en fait autant, comme Opus 4.8 dans ANTHROPIC_DEFAULT_OPUS_MODEL ou Sonnet 5 dans ANTHROPIC_DEFAULT_SONNET_MODEL, au moyen d'un identifiant que Claude Code peut faire correspondre à ce modèle.

Recherche en sécurité et charges de travail en biologie

Les charges de travail en sécurité offensive ou en biologie, notamment les tests d'intrusion, les exercices Capture the Flag (CTF) et les bases de code liées à la biologie, déclenchent fréquemment la bascule, souvent dès la première requête. Il s'agit d'un routage attendu pour ces domaines, et non d'un signalement de votre compte. Si votre organisation a besoin de capacités de classe Fable pour ce travail, renseignez-vous auprès de votre équipe de compte Anthropic sur les programmes d'accès de confiance.

Pour un travail substantiel en biologie sur un modèle Fable ou Opus 5.5, la première requête signalée qui change de modèle fait passer la session sur Opus 5. Les requêtes ultérieures signalées pour la biologie s'y terminent par des refus, car Opus 5 n'a pas de modèle de secours pour la biologie. Sur Opus 5 et Sonnet 5.5, ces refus commencent dès la première requête signalée.

Ajuster le niveau d'effort

Les niveaux d'effort contrôlent le raisonnement adaptatif, qui permet au modèle de décider s'il doit réfléchir à chaque étape, et dans quelle mesure, en fonction de la complexité de la tâche. Un effort plus faible est plus rapide et moins coûteux pour les tâches simples, tandis qu'un effort plus élevé offre un raisonnement plus approfondi pour les problèmes complexes.

Les niveaux d'effort disponibles dépendent du modèle. Les modèles non listés ici ne prennent pas en charge l'effort :

Si vous définissez un niveau que le modèle actif ne prend pas en charge, Claude Code se rabat sur le niveau pris en charge le plus élevé qui soit inférieur ou égal à celui que vous avez défini. Par exemple, xhigh s'exécute en tant que high sur Opus 4.6. Votre organisation ou vos propres paramètres peuvent également plafonner les niveaux proposés par un modèle ; consultez Limites d'effort de l'organisation.

Claude Code résout le niveau d'effort de la session dans cet ordre, en retenant le premier qui s'applique :

1. La variable d'environnement CLAUDE_CODE_EFFORT_LEVEL
2. Un niveau que vous choisissez dans la session, par exemple avec /effort, le sélecteur /model ou applyFlagSettings()
3. Un lancement avec --effort
4. Vos paramètres : le niveau que vous avez enregistré pour le modèle ou une clé effortLevel, avec la priorité entre eux et entre fichiers de paramètres indiquée à modelSettings
5. L'effort par défaut du modèle : Fable 5.2, Opus 5.5, Sonnet 5.5 et Haiku 5.5 sont à medium par défaut, et Opus 4.7 est à xhigh par défaut. Les autres modèles du tableau des niveaux d'effort sont à high par défaut. Si votre organisation définit un niveau d'effort par défaut pour son modèle par défaut de l'organisation, ce niveau est la valeur par défaut lorsque vous exécutez ce modèle.

Après une bascule automatique de modèle, consultez Niveau d'effort après une bascule pour connaître le niveau qui s'applique. Pour les sous-agents et les coéquipiers, consultez Niveau d'effort des sous-agents et des coéquipiers.

Opus 5.5 démarre à medium sauf si l'une des sources ci-dessus lui attribue un niveau, et une clé effortLevel de premier niveau dans votre fichier de paramètres utilisateur n'est pas prise en compte pour Opus 5.5. Cette clé est l'ancienne forme que /effort écrivait avant que Claude Code n'enregistre les niveaux par modèle : elle continue de s'appliquer là où elle s'appliquait auparavant, sur Opus 5, Fable 5.1 et les modèles antérieurs, tandis qu'Opus 5.5 et les modèles publiés après lui démarrent à leur propre valeur par défaut jusqu'à ce que vous leur choisissiez un niveau avec /effort ou le sélecteur /model. Une clé effortLevel de premier niveau dans les paramètres de projet, locaux ou gérés, ou transmise avec --settings, s'applique à tous les modèles.

Lorsque vous définissez low, medium, high ou xhigh dans une session interactive sur votre machine, vous choisissez sa durée selon la façon dont vous le confirmez :

• Enter dans le curseur /effort ou le sélecteur /model, ou un niveau saisi après /effort : enregistrer le niveau comme valeur par défaut et l'appliquer dans les sessions suivantes
• s dans le curseur /effort ou le sélecteur /model : appliquer le niveau à cette session uniquement. Nécessite Claude Code v2.1.257 ou une version ultérieure

Claude Code enregistre le niveau par modèle, sous la clé modelSettings de vos paramètres utilisateur, de sorte que chaque modèle conserve son propre niveau enregistré.

max est le niveau de raisonnement le plus approfondi. Sauf si vous le définissez au moyen de la variable d'environnement CLAUDE_CODE_EFFORT_LEVEL, Claude Code applique max à la session en cours uniquement.

[!NOTE]

Un niveau que vous choisissez à partir du contrôle d'effort sur un téléphone ou un navigateur connecté via Remote Control s'applique à cette session uniquement.

Lorsque vous définissez un niveau avec /effort dans une exécution -p, Claude Code l'applique à cette session uniquement et ne l'enregistre pas comme valeur par défaut.

Le curseur /effort comporte également un interrupteur Ultracode. Ultracode est un paramètre de Claude Code plutôt qu'un niveau d'effort du modèle : lorsqu'il est activé, Claude orchestre des workflows dynamiques pour les tâches substantielles, quel que soit le niveau d'effort de la session. Pour savoir où le définir de façon persistante, consultez le paramètre ultracode.

Activer ou désactiver ultracode avec /effort ou le paramètre ultracode laisse le niveau d'effort inchangé. Le flag --effort ultracode et la valeur effortLevel: "ultracode" de l'Agent SDK l'activent et définissent également le niveau sur xhigh. Choisir un niveau dans le curseur /effort ou le sélecteur /model laisse ultracode dans son état.

Vous pouvez activer ultracode de l'une des manières suivantes :

• /effort : exécutez /effort ultracode pour l'activer pour la session en cours ou /effort ultracode off pour le désactiver. Dans le curseur /effort, appuyez sur Tab pour basculer l'interrupteur Ultracode, puis sur Enter pour l'appliquer
• Flag --effort : lancez avec claude --effort ultracode, qui démarre la session avec l'effort xhigh et ultracode activé
• Paramètre ultracode : définissez "ultracode": true dans un fichier de paramètres, avec --settings, ou dans une requête de contrôle de l'Agent SDK. Une requête applyFlagSettings() accepte également effortLevel: "ultracode", qui l'active et définit le niveau d'effort sur xhigh

La forme /effort ultracode off, l'interrupteur du curseur et le maintien d'ultracode activé à des niveaux d'effort autres que xhigh nécessitent Claude Code v2.1.284 ou une version ultérieure. Avant la v2.1.284, activer ultracode réglait la session sur l'effort xhigh, choisir un autre niveau le désactivait, et un plafond d'effort inférieur à xhigh le rendait indisponible.

Transmettre ultracode au flag --effort ou à la valeur effortLevel de l'Agent SDK nécessite Claude Code v2.1.203 ou une version ultérieure. Avant la v2.1.203, --effort ultracode affichait Unknown --effort value 'ultracode' et la session démarrait avec l'effort par défaut.

Le paramètre persistant effortLevel et la variable d'environnement CLAUDE_CODE_EFFORT_LEVEL n'acceptent pas ultracode. Si CLAUDE_CODE_EFFORT_LEVEL ou un plafond d'effort définit le niveau de la session, ultracode reste activé à ce niveau.

Ultracode est indisponible lorsque :

• Les workflows sont désactivés
• Le modèle ne prend pas en charge l'effort xhigh

Dans ces cas, --effort ultracode démarre la session avec ultracode désactivé, au niveau d'effort le plus élevé que le modèle et tout plafond autorisent, jusqu'à xhigh.

Choisir un niveau d'effort

Chaque niveau arbitre entre la dépense de tokens et les capacités. La valeur par défaut convient à la plupart des tâches de code ; ajustez-la lorsque vous souhaitez un autre équilibre.

Lors de tests sur Opus 5.5 et Fable 5.1, Claude à un niveau plus élevé a testé davantage de cas limites et vérifié une plus grande part de son travail avant de répondre. Il a également pris davantage de décisions par lui-même. À un niveau plus faible, Claude a renvoyé plus tôt un point de départ, ce qui convient au travail où vous examinez chaque résultat et orientez l'étape suivante. Pour voir les mêmes tâches exécutées à chaque niveau, lisez Using Claude Code: Spending your effort sur le blog.

L'échelle d'effort est calibrée pour chaque modèle ; un même nom de niveau ne représente donc pas la même valeur sous-jacente d'un modèle à l'autre.

Opus 5.5 est à medium par défaut, un niveau en dessous de la valeur par défaut high d'Opus 5. Lors des tests d'Anthropic, Opus 5.5 à medium égale ou dépasse Opus 5 à high sur les évaluations de code et de travail intellectuel. À niveau égal, Opus 5.5 a tendance à réfléchir davantage par tour qu'Opus 5. Lorsque vous passez d'Opus 5 à Opus 5.5, commencez à medium plutôt que de reprendre le niveau que vous utilisiez sur Opus 5. Pour tester les niveaux sur votre propre travail, consultez Calibrate effort dans le guide de prompting d'Opus 5.5.

Utiliser ultrathink pour un raisonnement approfondi ponctuel

Incluez ultrathink n'importe où dans votre prompt pour demander un raisonnement plus approfondi sur ce tour sans modifier le paramètre d'effort de votre session. Claude Code reconnaît le mot-clé et ajoute une instruction dans le contexte. Claude Code transmet d'autres expressions comme « think », « think hard » et « think more » en tant que texte ordinaire du prompt et ne les reconnaît pas comme des mots-clés.

Saisi dans le prompt du terminal, le mot peut également faire passer ce tour à l'effort xhigh. Lorsque c'est possible, le mot s'affiche aux couleurs de l'arc-en-ciel. Nécessite Claude Code v2.1.311 ou une version ultérieure. Si le mot ne s'affiche pas en arc-en-ciel lorsque vous commencez un nouveau tour, essayez l'une de ces solutions :

• Saisissez-le de nouveau en dehors de tout élément comme des guillemets, des crochets, un chemin ou une commande, dans un prompt qui ne commence pas par /
• Supprimez CLAUDE_CODE_EFFORT_LEVEL s'il est défini en dessous de xhigh, augmentez votre propre maxEffortLevel à xhigh ou plus, ou demandez à un administrateur de l'organisation d'augmenter la limite de votre organisation
• Exécutez /model dans votre session pour passer à un modèle Opus 5.5, Sonnet 5.5, Haiku 5.5, Fable 5.2 ou Fable 5.1. Là où le mot ne peut pas augmenter un tour, comme sur Amazon Bedrock, définissez plutôt le niveau d'effort

Définir le niveau d'effort

Vous pouvez modifier l'effort de l'une des manières suivantes :

• /effort : exécutez /effort sans argument pour ouvrir un curseur interactif, /effort suivi d'un nom de niveau pour le définir directement, ou /effort auto pour effacer le niveau enregistré pour le modèle actif
• Dans /model : utilisez les flèches gauche/droite pour ajuster le curseur d'effort lors de la sélection d'un modèle. Le nouveau niveau prend effet au plus tard avec votre prochain message. D'ici là, Claude peut continuer à travailler à l'ancien niveau, même sur un nouveau modèle. Tant qu'une source prioritaire sur votre choix s'applique, comme CLAUDE_CODE_EFFORT_LEVEL, Claude travaille plutôt au niveau de cette source.
• Flag --effort : transmettez un nom de niveau pour le définir pour une seule session au lancement de Claude Code
• Variable d'environnement : définissez CLAUDE_CODE_EFFORT_LEVEL sur un nom de niveau. Pour que Claude Code n'envoie aucun niveau d'effort, définissez-la plutôt sur auto ou unset
• Paramètres : définissez un niveau par modèle dans modelSettings, ou définissez effortLevel sur low, medium, high ou xhigh comme valeur par défaut pour les modèles qui n'en ont pas. max n'est accepté comme niveau dans aucune de ces clés, et ultracode dispose de sa propre clé ultracode
• Depuis un appareil connecté : dans une session Remote Control, choisissez un niveau à partir du contrôle d'effort sur votre téléphone ou dans votre navigateur. Le niveau s'applique uniquement à la session en cours. Nécessite Claude Code v2.1.234 ou une version ultérieure
• Frontmatter de skill et de sous-agent : définissez effort dans le fichier markdown d'un skill ou d'un sous-agent pour remplacer le niveau d'effort lorsque ce skill ou ce sous-agent s'exécute

Le effort d'un skill s'applique jusqu'à la fin du tour dans lequel il s'exécute, ou pendant l'exécution du sous-agent dérivé avec context: fork. Le effort d'un sous-agent s'applique pendant que le sous-agent s'exécute, sauf si son invocation le remplace. Tant que l'un ou l'autre s'applique, le skill ou le sous-agent s'exécute à son niveau, quel que soit le niveau avec lequel vous lancez, que vous enregistrez ou que vous choisissez. Si CLAUDE_CODE_EFFORT_LEVEL est défini, c'est plutôt ce niveau qui s'applique.

Un maxEffortLevel ou un plafond d'effort de l'organisation limite toujours le niveau auquel le skill ou le sous-agent s'exécute. Si vous définissez effortLevel dans les paramètres gérés, Claude Code l'applique à l'étape des paramètres de l'ordre de résolution de l'effort, et les utilisateurs peuvent toujours modifier le niveau avec /effort ou --effort. Pour maintenir les utilisateurs à un niveau donné ou en dessous, définissez maxEffortLevel.

Niveau d'effort des sous-agents et des coéquipiers

Sur le modèle de la conversation principale, un sous-agent ou un coéquipier sans effort propre s'exécute au niveau que vous choisissez dans la session ou que vous définissez avec --effort. Sur un autre modèle, ce niveau ne s'applique pas. Pour choisir le niveau d'un sous-agent, définissez effort dans sa définition.

Vérifier le niveau d'effort défini

Le curseur d'effort apparaît dans /model lorsqu'un modèle compatible est sélectionné. Un niveau affiché dans l'en-tête de la session, par exemple « with low effort », provient de votre paramètre d'effort, même si Claude travaille encore à l'ancien niveau. Au démarrage et lorsque vous le modifiez, le pied de page affiche aussi brièvement le niveau défini pour votre session.

Quand un nouveau niveau d'effort prend effet

Dans une session de terminal, une fois que /effort confirme le nouveau niveau, le prochain message que vous envoyez s'exécute à ce niveau. Vous pouvez l'envoyer après la fin du tour en cours ou pendant que Claude travaille encore :

• Après la fin du tour : vous n'avez rien à faire d'ici là, et il est normal que le tour se termine à l'ancien niveau
• Pendant que Claude travaille encore : saisissez un message, comme keep going, et appuyez sur Enter pour le mettre en file d'attente sans interrompre le tour. Claude le reçoit lorsque ses appels d'outils en cours se terminent, ou au plus tard à la fin du tour, et travaille au nouveau niveau à partir de ce moment.

Avant la v2.1.242, Claude Code pouvait mettre /effort lui-même en file d'attente jusqu'à la fin du tour, et le faisait toujours dans une session qui ne récupère pas les feature flags, comme sur un fournisseur tiers.

N'envoyer aucun niveau d'effort

Lorsque Claude Code n'envoie aucun niveau d'effort à un modèle compatible, c'est la valeur par défaut de l'API qui s'applique plutôt que celle de Claude Code. Pour que Claude Code n'en envoie aucun, démarrez claude depuis un shell qui exporte CLAUDE_CODE_EFFORT_LEVEL avec la valeur auto ou la valeur unset, qui ont le même effet :

export CLAUDE_CODE_EFFORT_LEVEL=auto

L'en-tête et le pied de page de la session n'affichent aucun niveau d'effort tant qu'aucun n'est envoyé. Pour confirmer qu'aucun n'est envoyé, exécutez /effort status dans le prompt de Claude Code :

• Effort level: auto : aucun niveau d'effort n'est envoyé.
• Effort level: auto (currently <level>) : un niveau est encore envoyé. Si un paramètre maxEffortLevel inférieur à max s'applique au modèle actif, Claude Code envoie sa propre valeur par défaut pour le modèle, abaissée à ce plafond. Supprimez le paramètre ou définissez-le sur max.

[!NOTE]

Avant la v2.1.304, /effort status affichait Effort level: auto (currently high) même lorsqu'aucun niveau n'était envoyé.

Raisonnement adaptatif et budgets de réflexion fixes

Le raisonnement adaptatif rend la réflexion facultative à chaque étape : Claude peut ainsi répondre plus vite aux prompts courants et réserver une réflexion plus approfondie aux étapes qui en bénéficient. Si vous souhaitez que Claude réfléchisse plus ou moins souvent que ne le produit le niveau actuel, vous pouvez le dire directement dans votre prompt ou dans CLAUDE.md ; le modèle suit ces indications dans les limites de son paramètre d'effort.

Les modèles Fable, Sonnet 5 et versions ultérieures, Haiku 5.5, et Opus 4.7 et versions ultérieures utilisent toujours le raisonnement adaptatif. Le mode de budget de réflexion fixe et CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING ne s'appliquent pas à eux.

Sur Opus 4.6 et Sonnet 4.6, vous pouvez définir CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 pour revenir à l'ancien budget de réflexion fixe contrôlé par MAX_THINKING_TOKENS. Consultez variables d'environnement.

Réflexion étendue

La réflexion étendue est le raisonnement que Claude produit avant de répondre. Sur les modèles qui prennent en charge le raisonnement adaptatif, le niveau d'effort est le principal moyen de contrôler la quantité de réflexion ; les paramètres ci-dessous activent ou désactivent la réflexion et contrôlent son affichage. Lorsque la réflexion est désactivée sur l'API Anthropic, Claude Code envoie l'effort high au lieu d'un niveau supérieur aux modèles dont il sait qu'ils n'acceptent pas cette combinaison, comme Opus 5.

Claude Code réduit l'affichage de la réflexion par défaut. Appuyez sur Ctrl+O pour basculer le mode verbeux et voir le raisonnement en texte italique gris. Les sessions interactives sur l'API Anthropic reçoivent par défaut des blocs de réflexion expurgés ; définissez donc showThinkingSummaries: true dans les paramètres si vous souhaitez que les résumés complets soient disponibles lorsque vous les développez. Tous les tokens de réflexion générés vous sont facturés, même lorsqu'ils sont réduits ou expurgés.

Où vous ne pouvez pas désactiver la réflexion

Vous ne pouvez pas désactiver la réflexion sur Opus 5.5, Sonnet 5.5, Haiku 5.5 ou les modèles Fable. Le bouton de la session et la ligne de /config affichent Thinking can't be turned off pour ces modèles au lieu de proposer l'interrupteur, et un alwaysThinkingEnabled: false ou un MAX_THINKING_TOKENS=0 enregistré n'y a aucun effet. Sur ces modèles, le modèle décide à chaque étape de la quantité de réflexion en fonction du niveau d'effort. Le paramètre enregistré s'applique de nouveau lorsque vous passez à un modèle qui l'accepte.

Pour arrêter ou réduire la réflexion, suivez l'étape correspondant à votre fournisseur :

• API Anthropic : vous pouvez désactiver la réflexion sur des modèles comme claude-opus-5, claude-sonnet-5 et claude-haiku-4-5. Les alias comme sonnet sélectionnent des modèles sur lesquels ce n'est pas possible ; définissez donc le modèle par son identifiant.
• Fournisseurs tiers : sur des fournisseurs comme Amazon Bedrock et Microsoft Foundry, les modèles dotés du raisonnement adaptatif peuvent encore réfléchir même lorsque la réflexion est désactivée. Abaissez le niveau d'effort pour réduire la réflexion.

Contexte étendu

Les longues sessions sur de grandes bases de code peuvent utiliser une fenêtre de contexte de 1 million de tokens. Les modèles Fable, Sonnet 5 et versions ultérieures, Haiku 5.5, Opus 4.6 et versions ultérieures, et Sonnet 4.6 la prennent en charge.

Les modèles Fable, Sonnet 5 et versions ultérieures, Haiku 5.5, et Opus 4.7 et versions ultérieures fonctionnent par défaut avec la fenêtre de 1M, sans suffixe [1m] nécessaire. Cela inclut les sessions sur Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry, ainsi que les sessions Claude apps gateway. Pour les exécuter plutôt avec une fenêtre de 200K, consultez Désactiver le contexte de 1M.

Opus 4.6 et Sonnet 4.6 n'atteignent 1M que via leur variante [1m], et l'accès à cette variante dépend de votre forfait. Sur les forfaits Max, Ultra, Team et Enterprise, y compris pour les sièges Team Standard et Team Premium, Opus 4.6 avec un contexte de 1M est inclus dans votre abonnement. Sonnet 4.6 avec un contexte de 1M nécessite des crédits d'utilisation sur tous les forfaits d'abonnement, y compris Max et Ultra.

Claude Code ne vérifie ces exigences de forfait que lorsqu'il se connecte directement à l'API Anthropic. Si vous faites pointer ANTHROPIC_BASE_URL vers une passerelle LLM et que votre connexion claude.ai enregistrée reste l'identifiant actif, Claude Code ne vérifie pas les crédits d'utilisation de votre forfait. Les options [1m] restent disponibles dans /model, et c'est la passerelle qui décide si la requête aboutit. Avant la v2.1.229, Claude Code rejetait /model sonnet[1m] dans cette configuration lorsqu'il ne pouvait pas confirmer les crédits d'utilisation du compte.

Sur l'API Anthropic, la fenêtre de contexte de 1M utilise la tarification standard du modèle, sans supplément pour les tokens au-delà de 200K, sauf sur Haiku 5.5, qui coûte plus cher pour les prompts de plus de 100K tokens. Pour les forfaits dont l'abonnement inclut le contexte étendu, l'utilisation reste couverte par votre abonnement. Pour les forfaits qui accèdent au contexte étendu via des crédits d'utilisation, les tokens sont facturés sur les crédits d'utilisation.

Sélectionner le contexte de 1M pour Opus 4.6 ou Sonnet 4.6

Pour sélectionner une variante 1M par son nom, ajoutez le suffixe [1m] à un alias de modèle ou à un nom de modèle complet :

# Append [1m] to a full model name
/model claude-opus-4-6[1m]
/model claude-sonnet-4-6[1m]

# Or to an alias: the suffix applies to the model the alias resolves to
/model opus[1m]

Fenêtre de contexte derrière une passerelle LLM

Si vous définissez ANTHROPIC_BASE_URL sur une passerelle LLM ou un autre proxy, Claude Code attribue à chaque modèle qu'il reconnaît la même fenêtre de contexte que celle dont le modèle dispose sur l'API Anthropic. Les modèles Fable, Sonnet 5 et versions ultérieures, Haiku 5.5, et Opus 4.7 et versions ultérieures obtiennent la fenêtre de 1M sans variante [1m]. Un modèle qui n'atteint 1M que via sa variante [1m], comme Opus 4.6, fonctionne à 200K sans elle.

Claude Code ne peut pas détecter une limite inférieure imposée par la passerelle ou par le serveur situé derrière. Si votre passerelle rejette les requêtes au-delà de 200K tokens, définissez CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000 dans l'environnement qui démarre Claude Code, afin que les sessions sur tous les modèles se compactent à cette limite.

Désactiver le contexte de 1M

Pour maintenir les sessions à une fenêtre de 200K, définissez CLAUDE_CODE_DISABLE_1M_CONTEXT=1 dans votre shell ou dans un fichier de paramètres. Claude Code retire les variantes de modèle [1m] du sélecteur de modèle. Sur les modèles qui fonctionnent par défaut avec la fenêtre de 1M, comme les modèles Fable, Sonnet 5 et versions ultérieures, et Opus 4.7 et versions ultérieures, il traite également le modèle comme disposant d'une fenêtre de contexte de 200K :

• Avec la compaction automatique activée, les sessions se compactent à la limite de 200K via la compaction automatique. Définir une fenêtre de compaction automatique supérieure à 200K ne lève pas cette limite, car Claude Code plafonne cette fenêtre à la fenêtre de contexte du modèle.
• Avec la compaction automatique désactivée, les sessions s'arrêtent à la limite de 200K avec l'erreur de limite de contexte au lieu de se compacter.

Fenêtre de contexte et tarification de Haiku 5.5

Sur l'API Anthropic, Haiku 5.5 fonctionne avec la fenêtre de contexte de 1M sur tous les forfaits, sans suffixe [1m] à sélectionner. Son identifiant de modèle est claude-haiku-5-5. Pour l'utiliser, exécutez /model claude-haiku-5-5 dans une session, ou démarrez Claude Code depuis votre shell avec claude --model claude-haiku-5-5.

Une requête Haiku 5.5 coûte plus cher par token lorsque son prompt dépasse 100K tokens. Consultez la tarification d'Anthropic pour les deux tarifs.

Les sessions se compactent automatiquement à environ 967K tokens par défaut. Pour compacter plus tôt, définissez une fenêtre de compaction automatique plus petite pour le modèle.

Fenêtre de contexte et compaction automatique

La fenêtre de compaction automatique détermine le taux de remplissage de la fenêtre de contexte avant que Claude Code compacte la conversation. Pour savoir ce que la compaction conserve et supprime selon chaque mécanisme, consultez Ce qui survit à la compaction.

Définir la fenêtre de compaction automatique

[!NOTE]

Si Claude Code a émis un avertissement concernant la valeur de CLAUDE_CODE_AUTO_COMPACT_WINDOW, consultez les valeurs et avertissements de la variable.

Vous pouvez définir la fenêtre de compaction automatique aux endroits suivants :

• Pour le modèle actuel, dans cette session et les sessions ultérieures : exécutez /autocompact avec une valeur, comme /autocompact 500k. Claude Code l'enregistre dans vos paramètres utilisateur sous le modèle actuel dans modelSettings et l'applique à la session actuelle. Si une portée de paramètres de priorité plus élevée, comme les paramètres gérés, définit sa propre fenêtre pour ce modèle ou pour tous les modèles, la commande enregistre votre valeur mais la session conserve la fenêtre de cette portée, et la commande vous l'indique. Exécutez /autocompact auto pour revenir à la fenêtre optimisée pour votre modèle. Avant la v2.1.288, la commande enregistrait une seule fenêtre pour tous les modèles, sous la clé de premier niveau autoCompactWindow.
• Pour tous les modèles : définissez autoCompactWindow dans un fichier de paramètres, comme "autoCompactWindow": 200000 dans ~/.claude/settings.json. Une fenêtre que vous avez enregistrée pour un modèle avec /autocompact a priorité sur cette clé dans le même fichier pour ce modèle.
• Pour un lancement : passez --autocompact au démarrage de Claude Code. Le flag remplace votre paramètre enregistré pour ce lancement sans le modifier, et claude --autocompact auto exécute la session à la fenêtre optimisée même si votre paramètre enregistré a une valeur. Contrairement à /autocompact, le flag n'est pas préempté par une portée de paramètres de priorité plus élevée, comme les paramètres gérés.
• Dans les scripts et les environnements cloud : définissez CLAUDE_CODE_AUTO_COMPACT_WINDOW sur un nombre de tokens comme 200000. Sauf si Claude Code ignore la valeur, la variable a priorité sur la commande, le flag et le paramètre autoCompactWindow. /autocompact signale alors le remplacement sans enregistrer. Le used_percentage de la barre de statut est mesuré par rapport à la fenêtre de contexte complète du modèle ; tant que la variable est définie, ce pourcentage n'indique donc pas quand la compaction aura lieu.
• Pour un sous-agent : consultez Définir la fenêtre de compaction automatique pour un sous-agent.

La commande et le flag acceptent une taille de fenêtre de 100 K à 1 M de tokens, sous l'une de ces formes :

• Un nombre de tokens simple, comme 200000
• Un suffixe k ou M, comme 500k ou 1M
• Un nombre simple de 100 à 1 000, signifiant des milliers, donc 200 définit 200 000

Quelle que soit la manière dont vous définissez la fenêtre, Claude Code la limite à la fenêtre de contexte du modèle.

Valeurs et avertissements pour CLAUDE_CODE_AUTO_COMPACT_WINDOW

Un avertissement qui cite votre valeur de CLAUDE_CODE_AUTO_COMPACT_WINDOW signifie que cette valeur se situe en dehors de la plage de 100 000 à 1 000 000 ou n'est pas un nombre de tokens. Pour faire disparaître l'avertissement, définissez un nombre dans cette plage, comme CLAUDE_CODE_AUTO_COMPACT_WINDOW=200000. Sur Claude Code v2.1.304 ou ultérieure, vous pouvez également écrire le nombre avec k pour les milliers ou M pour les millions, comme 200k ou 1M.

Repérez le libellé de votre avertissement dans la première colonne, puis lisez la ligne pour connaître la fenêtre utilisée par votre session et ce qu'il faut modifier :

Un nombre sans suffixe est lu comme autant de tokens : CLAUDE_CODE_AUTO_COMPACT_WINDOW=200 signifie donc 200 tokens, alors que /autocompact 200 signifie 200 000.

Seuils de compaction automatique par défaut

Si vous ne définissez pas de fenêtre de compaction automatique, Claude Code compacte lorsque la conversation atteint la limite de contexte du modèle, sauf dans ces sessions :

• Les sessions cloud se compactent à mesure que la conversation approche de la limite du modèle
• Sonnet 4.6 et Opus 4.6 sans contexte étendu se compactent à la limite de 200 K
• Lorsque vous définissez CLAUDE_CODE_DISABLE_1M_CONTEXT=1, les modèles avec une fenêtre native de 1 M, comme Sonnet 5 et les modèles Fable, se compactent à la limite de 200 K
• Les modèles s'exécutant avec une fenêtre native de 1 M se compactent avant que la fenêtre ne se remplisse, à environ 967 K tokens par défaut. Ceux-ci incluent les modèles Fable, Sonnet 5 et versions ultérieures, Haiku 5.5, et Opus 4.7 et versions ultérieures. Derrière une ANTHROPIC_BASE_URL personnalisée, consultez la fenêtre de contexte derrière une passerelle
• Les sessions sur un ID de modèle que Claude Code ne reconnaît pas, comme un alias de passerelle LLM, se compactent à la fenêtre de contexte que Claude Code suppose pour l'ID ; consultez Corriger la fenêtre pour une passerelle ou un ID de modèle personnalisé

Consultez le paramètre idleCompaction pour savoir quand Claude Code compacte également une conversation que vous laissez inactive.

Corriger la fenêtre pour une passerelle ou un ID de modèle personnalisé

L'un ou l'autre de ces avertissements au démarrage signifie que Claude Code ne reconnaît pas l'ID de modèle de votre session ; il ne peut donc pas déterminer la fenêtre de contexte du modèle et suppose 200 K tokens :

⚠ Model "my-gateway-opus" isn't recognized · context assumed to be 200k tokens · ...
Claude Code doesn't recognize the model "my-gateway-opus", so it assumes a context window of 200k tokens. Update Claude Code, or see https://code.claude.com/docs/en/model-config#correct-the-window-for-a-gateway-or-custom-model-id to set the window.

Claude Code compacte automatiquement la conversation aux 200 K supposés ; si la fenêtre de contexte réelle du modèle est de 200 K, il n'y a donc rien à corriger. Sinon, indiquez à Claude Code la fenêtre réelle de l'une des manières suivantes, selon votre ID :

• Un modèle plus récent que votre version de Claude Code : exécutez claude update dans votre shell. Si Claude Code reconnaît l'ID après la mise à jour, vous n'avez rien d'autre à configurer.
• Le nom donné par votre passerelle ou votre fournisseur à un modèle que Claude Code connaît : ajoutez une entrée modelOverrides qui associe l'ID de modèle Anthropic à votre ID, comme "claude-opus-4-8": "my-gateway-opus". Vous pouvez également lister votre ID dans une ligne modelPicker avec behavesAs défini sur ce modèle. Dans les deux cas, Claude Code traite alors l'ID comme ce modèle.
• Un modèle avec une fenêtre de 1 M : ajoutez [1m] à l'ID là où vous définissez le modèle, comme claude --model 'my-gateway-opus[1m]' dans votre shell. Si vous avez désactivé le contexte 1M, vous obtenez la même fenêtre avec ou sans le suffixe.
• Toute autre fenêtre : définissez CLAUDE_CODE_MAX_CONTEXT_TOKENS sur la taille de la fenêtre en tokens dans l'environnement qui démarre Claude Code, comme CLAUDE_CODE_MAX_CONTEXT_TOKENS=400000. Pour un ID non reconnu qui ne commence pas par claude- et n'a pas de suffixe [1m], la variable prend effet d'elle-même. Pour tout autre ID, vérifiez d'abord à quels ID elle s'applique.

Une fois que Claude Code reconnaît l'ID ou utilise la fenêtre que vous lui avez indiquée, l'avertissement n'apparaît plus lorsque vous démarrez une session sur cet ID.

À quels ID s'applique CLAUDE_CODE_MAX_CONTEXT_TOKENS

Sur une passerelle LLM ou un autre déploiement personnalisé, Claude Code peut supposer une fenêtre de contexte pour l'ID de modèle qui diffère de la fenêtre réelle du modèle, qu'il résolve ou non l'ID en un modèle Claude. Définissez CLAUDE_CODE_MAX_CONTEXT_TOKENS à la fenêtre que Claude Code devrait supposer à la place.

La façon dont la variable s'applique dépend de l'ID. Claude Code traite un ID comme un fournisseur ou une orthographe personnalisée lorsqu'il ne commence pas par claude-, en toute casse, ou lorsqu'il porte un suffixe que Claude Code supprime lors de la lecture de l'ID, comme la date @YYYYMMDD utilisée sur Google Cloud's Agent Platform. Avant la v2.1.259, Claude Code ne comptait pas un suffixe supprimé, donc un ID claude- non reconnu avec un suffixe de date était traité comme un nom claude- simple.

Un fournisseur ou une orthographe personnalisée non reconnu, la même orthographe avec [1m], et tous les autres ID sont trois cas distincts :

• Si Claude Code ne peut pas résoudre un fournisseur ou une orthographe personnalisée en un modèle qu'il reconnaît et que l'ID ne contient pas [1m], la variable s'applique directement et la compaction proactive continue à la fenêtre déclarée.

• Si Claude Code ne peut pas résoudre un fournisseur ou une orthographe personnalisée en un modèle qu'il reconnaît et que l'ID contient [1m], en toute casse, Claude Code suppose une fenêtre de 1 M pour celui-ci et la variable ne s'applique pas d'elle-même. Pour corriger la fenêtre tout en maintenant la compaction proactive, définissez également CLAUDE_CODE_DISABLE_1M_CONTEXT=1. Avec cette variable définie, Claude Code dimensionne l'ID comme la même orthographe sans [1m], donc CLAUDE_CODE_MAX_CONTEXT_TOKENS s'applique lorsqu'il s'appliquerait à cette orthographe sans étiquette.

  Avec une fenêtre déclarée supérieure à 200 K, l'avertissement indiquant que la limite de 200 K n'est pas appliquée est attendu dans cette configuration.

• Si l'ID se résout en un modèle que Claude Code reconnaît, ou si l'ID est un nom claude- simple sans suffixe pour Claude Code à supprimer, en toute casse, la variable ne prend effet que lorsque vous définissez également DISABLE_COMPACT, ce qui désactive toute compaction.

  Par exemple, un ID qui contient un nom de modèle Claude que Claude Code connaît, comme anthropic/claude-opus-4-8, us.anthropic.claude-…-v1:0, ou le daté claude-sonnet-4-5@20250929, se résout en ce modèle. Cela inclut les ID qui contiennent également [1m] : Claude Code résout claude-opus-4-8[1m] en Opus 4.8 même avec CLAUDE_CODE_DISABLE_1M_CONTEXT défini.

Pour un ID de modèle que Claude Code ne reconnaît pas, définissez CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT=1 pour que Claude Code se compacte uniquement après que l'API rejette la conversation avec une erreur de longueur excessive que Claude Code reconnaît. Claude Code n'exécute pas cette récupération lorsqu'une passerelle réécrit l'erreur avec un libellé que Claude Code ne reconnaît pas.

Vérifier votre modèle actuel

Vous pouvez voir quel modèle vous utilisez actuellement de plusieurs façons :

• Dans la ligne d'état, si vous en avez une configurée
• Dans /status, qui affiche également vos informations de compte

Ajouter une option de modèle personnalisé

Utilisez ANTHROPIC_CUSTOM_MODEL_OPTION pour ajouter une seule entrée personnalisée au sélecteur /model sans remplacer les alias intégrés. Ceci est utile pour tester les ID de modèle que Claude Code ne répertorie pas par défaut. Pour les déploiements de passerelle LLM, Claude Code peut remplir le sélecteur à partir du point de terminaison /v1/models de la passerelle lorsque CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 est défini, donc cette variable n'est nécessaire que lorsque la découverte est désactivée ou ne retourne pas le modèle que vous souhaitez. Voir découverte du modèle de passerelle.

Pour lister plusieurs modèles à la place, dans votre propre ordre et sous les étiquettes que vous choisissez, définissez modelPicker. Son entrée indique quelles lignes le sélecteur conserve lorsque cet alignement remplace celui intégré.

Cet exemple définit les trois variables pour rendre un déploiement Opus acheminé par passerelle sélectionnable. Claude Code lit les variables d'environnement au démarrage, donc exécutez les exports avant de lancer claude, ou redémarrez une session existante pour les récupérer :

export ANTHROPIC_CUSTOM_MODEL_OPTION="my-gateway/claude-opus-5-5"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="Opus via Gateway"
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="Custom deployment routed through the internal LLM gateway"

ANTHROPIC_CUSTOM_MODEL_OPTION_NAME et ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION sont optionnels :

• Si vous omettez le nom, l'entrée affiche le nom du modèle lorsque Claude Code reconnaît l'ID, et l'ID du modèle sinon.
• Si vous omettez la description, Claude Code utilise Custom model (<model-id>).

Claude Code répertorie l'entrée personnalisée après les entrées intégrées, et toutes les lignes modelPicker que vous ajoutez viennent après.

Claude Code ignore la validation pour l'ID de modèle défini dans ANTHROPIC_CUSTOM_MODEL_OPTION, vous pouvez donc utiliser n'importe quelle chaîne que votre point de terminaison API accepte.

Lorsque availableModels est défini, incluez également l'ID de modèle personnalisé dans la liste d'autorisation. Sinon, Claude Code filtre l'entrée personnalisée du sélecteur et rejette une sélection --model de celui-ci comme tout autre modèle exclu.

Un ID personnalisé qui intègre un nom de famille, tel que my-gateway/claude-opus-5-5, compte comme une entrée spécifique pour cette famille et désactive son caractère générique, donc listez également les versions que vous avez l'intention de garder sélectionnables. Voir Comportement de fusion.

Variables d'environnement

Utilisez les variables d'environnement suivantes pour contrôler les noms de modèle auxquels les alias sont mappés. Chaque valeur doit être un nom de modèle complet, ou l'identifiant équivalent pour votre fournisseur d'API. Pour choisir le modèle sur lequel vos sessions démarrent, définissez ANTHROPIC_DEFAULT_MODEL, que ce tableau omet.

Sur les fournisseurs tiers, Personnaliser l'affichage et les capacités du modèle épinglé décrit ce qu'une ligne de modèle épinglé dans le sélecteur /model affiche.

Remarque : ANTHROPIC_SMALL_FAST_MODEL est déprécié au profit de ANTHROPIC_DEFAULT_HAIKU_MODEL.

Épingler les modèles pour les déploiements tiers

Lors du déploiement de Claude Code via Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, ou Claude Platform on AWS, épinglez les versions de modèle avant de les déployer auprès des utilisateurs.

Sans épinglage, Claude Code utilise les alias de modèle tels que fable, opus, sonnet et haiku qui se résolvent à un ID de modèle par défaut intégré pour chaque fournisseur. Ce défaut peut être en retard par rapport à la dernière version d'Anthropic, et le modèle auquel il pointe peut ne pas encore être activé dans le compte d'un utilisateur. Lorsque le défaut n'est pas disponible, les utilisateurs d'Amazon Bedrock et de Google Cloud's Agent Platform voient un avis et la session revient à une version antérieure du modèle par défaut, ou au modèle Sonnet par défaut lorsque le défaut est un modèle Opus et qu'aucune version Opus n'est disponible. Les utilisateurs de Microsoft Foundry voient des erreurs à la place, car Microsoft Foundry n'a pas de vérification de démarrage équivalente.

Sur Amazon Bedrock et Google Cloud's Agent Platform, un utilisateur qui démarre la session sur une version spécifique de Sonnet ou Opus, par exemple avec --model, ANTHROPIC_MODEL, ou le paramètre model, épingle cette version comme défaut de la session pour l'alias correspondant : la vérification de démarrage ignore le défaut intégré qu'il remplace et n'affiche aucun avis de basculement. Avant v2.1.211, la vérification s'exécutait et pouvait afficher un avis même lorsqu'un modèle de session était explicitement configuré.

[!WARNING]

Définissez les variables d'environnement de modèle sur des ID de version spécifiques dans le cadre de votre configuration initiale. L'épinglage vous permet de contrôler quand vos utilisateurs passent à un nouveau modèle.

Utilisez les variables d'environnement suivantes avec des ID de modèle spécifiques à la version pour votre fournisseur :

Appliquez le même modèle pour ANTHROPIC_DEFAULT_FABLE_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL et ANTHROPIC_DEFAULT_HAIKU_MODEL. Pour les ID de modèle actuels et hérités sur tous les fournisseurs, voir Aperçu des modèles. Pour mettre à niveau les utilisateurs vers une nouvelle version de modèle, mettez à jour ces variables d'environnement et redéployez.

Un modèle épinglé doté d'une fenêtre 1M native, tel qu'Opus 4.8 ou Sonnet 5, s'exécute avec la fenêtre de contexte 1M sans aucun suffixe lorsque Claude Code peut faire correspondre l'ID épinglé à ce modèle. L'ID correspond lorsqu'il contient l'ID API Anthropic du modèle, comme us.anthropic.claude-opus-4-8 contient claude-opus-4-8, ou lorsqu'une entrée modelOverrides mappe le modèle à cet ID. Pour un ID épinglé que Claude Code ne peut pas faire correspondre à un modèle, les sessions s'exécutent par défaut avec une fenêtre de 200K, sauf si l'ID porte le suffixe [1m].

Pour un modèle qui atteint 1M via sa variante [1m], tel qu'Opus 4.6 ou Sonnet 4.6, activez le contexte étendu en ajoutant [1m] à l'ID du modèle dans ANTHROPIC_DEFAULT_OPUS_MODEL ou ANTHROPIC_DEFAULT_SONNET_MODEL :

export ANTHROPIC_DEFAULT_OPUS_MODEL='claude-opus-4-6[1m]'

Avec le suffixe [1m], la fenêtre de contexte 1M s'applique à toute utilisation de l'alias épinglé, y compris la phase Opus en mode plan de opusplan et les sous-agents dont le frontmatter model nomme l'alias.

• Claude Code supprime le suffixe avant d'envoyer l'ID du modèle à votre fournisseur.
• N'ajoutez [1m] que lorsque le modèle sous-jacent prend en charge le contexte 1M.
• Le suffixe est lu par variable, et non par modèle. Sur Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry, un ID Opus 4.6 ou Sonnet 4.6 sans [1m] dans une variable utilise le contexte 200K même si une autre variable définit le même modèle avec le suffixe.

Lorsque vous définissez une variable ANTHROPIC_DEFAULT_*_MODEL, le sélecteur /model affiche une ligne pour ce modèle à la place des lignes intégrées de la famille, y compris les lignes de contexte 1M. Pour atteindre la fenêtre 1M sans ajouter le suffixe à cette variable, vos utilisateurs exécutent /model opus[1m], et Claude Code applique le suffixe au modèle que la variable nomme. /model sonnet[1m] fonctionne de la même manière.

[!NOTE]

Une liste d'autorisation availableModels livrée via MDM ou un fichier de paramètres gérés s'applique toujours lors de l'utilisation de fournisseurs tiers ; les paramètres gérés par le serveur ne sont pas livrés là.

Le filtrage correspond à un alias de modèle tel que opus, un préfixe de version tel que claude-opus-4-8, ou l'ID de modèle complet spécifique au fournisseur. Les préfixes spécifiques au fournisseur tels que us.anthropic. ne sont pas supprimés, donc pour autoriser un modèle spécifique, mappez-le via modelOverrides ou listez son ID complet spécifique au fournisseur :

• Google Cloud's Agent Platform : lorsque l'ID demandé par Claude Code comporte une date après @, comme claude-sonnet-4-5@20250929, incluez la date dans votre entrée de liste d'autorisation. À lui seul, claude-sonnet-4-5 ne correspond pas à cet ID, quel que soit le paramètre availableModelsMatch.
• Modèles épinglés : listez la valeur que vous avez définie dans la variable ANTHROPIC_DEFAULT_*_MODEL du modèle

Tout suffixe [1m] est supprimé de l'entrée de la liste d'autorisation et du modèle demandé avant la correspondance.

Personnaliser l'affichage et les capacités du modèle épinglé

Lorsque vous épinglez un modèle sur un fournisseur tiers, sa ligne dans le sélecteur /model affiche le nom du modèle par défaut si Claude Code reconnaît l'ID épinglé, et l'ID brut sinon :

• Reconnu : l'ID exact d'un modèle que Claude Code connaît, tel que son ID API Anthropic ou la forme de votre fournisseur ou passerelle, avec ou sans le suffixe [1m]. Épinglez us.anthropic.claude-sonnet-4-5-20250929-v1:0 et la ligne affiche Sonnet 4.5.
• Non reconnu : tout autre ID, tel qu'un ARN de profil d'inférence d'application ou une version de modèle que Claude Code ne connaît pas, sauf si une entrée modelOverrides mappe un modèle à cet ID. Sur Microsoft Foundry, les noms de déploiement sont définis par l'utilisateur, donc Claude Code ne reconnaît jamais un ID épinglé là, mappé ou non, et la ligne affiche le nom de déploiement par défaut.

Lorsqu'une ligne affiche le nom du modèle, sa description par défaut inclut l'ID épinglé afin que vous puissiez toujours voir quel ID est épinglé.

Claude Code peut également ne pas reconnaître les fonctionnalités qu'un modèle épinglé prend en charge. Vous pouvez définir vous-même le nom d'affichage et la description et déclarer les capacités avec des variables d'environnement complémentaires pour chaque modèle épinglé.

Ces variables prennent effet sur les fournisseurs tiers tels qu'Amazon Bedrock, Google Cloud's Agent Platform et Microsoft Foundry. Les variables _NAME et _DESCRIPTION prennent également effet lorsque ANTHROPIC_BASE_URL pointe vers une passerelle LLM. Elles n'ont aucun effet lors de la connexion directe à api.anthropic.com.

Les mêmes suffixes _NAME, _DESCRIPTION et _SUPPORTED_CAPABILITIES sont disponibles pour ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, ANTHROPIC_DEFAULT_FABLE_MODEL et ANTHROPIC_CUSTOM_MODEL_OPTION.

Claude Code active les fonctionnalités comme les niveaux d'effort et la réflexion étendue en faisant correspondre l'ID du modèle à des modèles connus. Les ID spécifiques au fournisseur tels que les ARN Amazon Bedrock ou les noms de déploiement personnalisés ne correspondent souvent pas à ces modèles, laissant les fonctionnalités prises en charge désactivées. Définissez _SUPPORTED_CAPABILITIES pour indiquer à Claude Code les fonctionnalités que le modèle prend réellement en charge :

Lorsque _SUPPORTED_CAPABILITIES est défini, Claude Code active les capacités listées et désactive les capacités non listées pour le modèle épinglé correspondant. Lorsque la variable n'est pas définie, Claude Code revient à la détection intégrée basée sur l'ID du modèle.

Cet exemple épingle Opus à un ARN de modèle personnalisé Amazon Bedrock, définit un nom convivial et déclare ses capacités :

export ANTHROPIC_DEFAULT_OPUS_MODEL='arn:aws:bedrock:us-east-1:123456789012:custom-model/abc'
export ANTHROPIC_DEFAULT_OPUS_MODEL_NAME='Opus via Bedrock'
export ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION='Opus 4.7 routed through a Bedrock custom endpoint'
export ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES='effort,xhigh_effort,max_effort,thinking,adaptive_thinking,interleaved_thinking'

Remplacer les ID de modèle par version

Sur les plateformes qui intègrent Claude Code et définissent CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST, la configuration du modèle de l'hôte prend la priorité sur les paramètres de modèle gérés, tandis qu'une liste d'autorisation availableModels gérée reste en vigueur sauf si l'hôte en fournit une ; Exceptions à la priorité des paramètres gérés indique quelles clés et variables l'hôte remplace.

Les variables d'environnement au niveau de la famille ci-dessus configurent un ID de modèle par alias de famille. Si vous devez mapper plusieurs versions au sein de la même famille à des ID de fournisseur distincts, utilisez plutôt le paramètre modelOverrides.

modelOverrides mappe les ID de modèle Anthropic individuels aux chaînes spécifiques au fournisseur que Claude Code envoie à l'API de votre fournisseur. Lorsqu'un utilisateur sélectionne un modèle mappé dans le sélecteur /model, Claude Code utilise votre valeur configurée au lieu de la valeur par défaut intégrée.

Cela permet aux administrateurs d'entreprise d'acheminer chaque version de modèle vers un ARN de profil d'inférence Amazon Bedrock spécifique, un nom de version Google Cloud's Agent Platform ou un nom de déploiement Microsoft Foundry pour la gouvernance, l'allocation des coûts ou l'acheminement régional.

Définissez modelOverrides dans votre fichier de paramètres :

{
  "modelOverrides": {
    "claude-opus-4-7": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-prod",
    "claude-opus-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/opus-46-prod",
    "claude-sonnet-4-6": "arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-prod"
  }
}

Les clés doivent être des ID de modèle Anthropic tels que listés dans l'Aperçu des modèles. Pour les ID de modèle datés, incluez le suffixe de date exactement tel qu'il apparaît là. Les clés inconnues sont ignorées.

Pour arrêter la ligne de diagnostic [claude-code:unrecognized_model] pour un ID tel qu'un alias de passerelle, ajoutez une entrée avec cet ID comme valeur.

Les remplacements remplacent les ID de modèle intégrés qui soutiennent chaque entrée dans le sélecteur /model. Sur Amazon Bedrock, les entrées modelOverrides prennent la priorité sur tous les profils d'inférence que Claude Code découvre automatiquement au démarrage. Claude Code transmet les valeurs qui sont déjà natives du fournisseur, telles que les ARN de profil d'inférence Amazon Bedrock ou les noms de déploiement Microsoft Foundry, au fournisseur telles quelles.

Les remplacements s'appliquent également lorsque vous transmettez un ID de modèle Anthropic directement via --model, la variable d'environnement ANTHROPIC_MODEL, ou une variable d'environnement ANTHROPIC_DEFAULT_*_MODEL. Sur Amazon Bedrock, Google Cloud's Agent Platform et Mantle, un ID de modèle Anthropic sans entrée modelOverrides se résout au même ID spécifique au fournisseur que la ligne du sélecteur /model pour cette version, lorsque le fournisseur prend en charge cette version. Mantle prend en charge un sous-ensemble de versions. Pour un ID de modèle Anthropic en dehors de ce sous-ensemble, Claude Code envoie l'ID brut à Mantle sans le mapper, sauf si une entrée modelOverrides le couvre. Avant v2.1.200, --model et les valeurs des variables d'environnement atteignaient le fournisseur telles quelles sans passer par la carte de remplacement.

modelOverrides fonctionne aux côtés de availableModels. La liste d'autorisation est évaluée par rapport à l'ID de modèle Anthropic, et non à la valeur de remplacement, donc une entrée comme "opus" dans availableModels continue de correspondre même lorsque les versions d'Opus sont mappées à des ARN. Lorsque enforceAvailableModels est défini dans les paramètres gérés, la valeur par défaut appliquée se résout via modelOverrides à partir des paramètres gérés uniquement. Le mappage d'un administrateur, tel qu'une version épinglée à un ARN de profil d'inférence, est honoré dans la valeur par défaut appliquée. Les remplacements des paramètres utilisateur ou projet ne l'affectent pas.

Lorsque availableModels est défini dans les paramètres gérés, seuls les modelOverrides des paramètres gérés s'appliquent à un ID de modèle Anthropic transmis directement via --model ou les variables d'environnement ci-dessus. Claude Code ignore les remplacements dans les paramètres utilisateur ou projet pour ces ID, et ne résout jamais un ID que la liste gérée exclut via modelOverrides à partir de n'importe quelle source de paramètres. Cette restriction de source gérée nécessite Claude Code v2.1.200 ou ultérieur. Voir Restreindre la sélection de modèle pour savoir comment les ID bloqués sont gérés.

Configuration du prompt caching

Claude Code utilise automatiquement le prompt caching pour optimiser les performances et réduire les coûts. Vous pouvez désactiver le prompt caching globalement ou pour des niveaux de modèle spécifiques :

Pour choisir vous-même le TTL du cache pour la conversation principale et pour les sous-agents séparément, voir choisir vous-même le TTL. Pour ce qui déclenche un échec du cache, voir Comment Claude Code utilise le prompt caching.

Historique des versions

Ce tableau répertorie la version de Claude Code à laquelle chaque alias de modèle a changé le modèle qu'il résout, du plus récent au plus ancien.