`.
4. **Fichier de paramètres** : le champ `model` dans `~/.claude/settings.json`.
Commandes de base :
```bash
# Lancer avec le modèle haut de gamme (actuellement Opus 5.5)
claude --model opus
# Passer à Sonnet pendant une session
/model sonnet
# Ouvrir le menu de sélection (pour un choix interactif)
/model
# Passer à Opus avec un contexte de 1M
/model opus[1m]
# Passer à une version spécifique (épingler)
/model claude-opus-5-5
```
Alias et modèles auxquels ils correspondent dans l’API Anthropic (au 23 septembre 2026) :
- `opus` → Opus 5.5 (nécessite Claude Code v2.1.280 ou version ultérieure)
- `sonnet` → Sonnet 5
- `haiku` → Haiku 4.5
- `best` → le modèle disponible le plus performant
- `default` → Opus 5.5 sur Pro, Max, Team, Enterprise et l’API Anthropic
- `opusplan` → un hybride Opus + Sonnet (examiné séparément plus bas)
⚠️ Les valeurs par défaut diffèrent chez les fournisseurs cloud : sur Amazon Bedrock et Google Cloud, l’alias `sonnet` désigne Sonnet 4.5 ; sur Microsoft Foundry, `opus` correspond toujours à Opus 4.6. Si vous passez par un fournisseur cloud, épinglez une version précise (`claude-opus-5-5`) ou définissez la variable `ANTHROPIC_DEFAULT_OPUS_MODEL`.
Depuis la version 2.1.144, le principal changement est que `/model` n’enregistre plus le choix dans les paramètres. Il s’applique à la session en cours et disparaît à sa fermeture. Pour enregistrer définitivement un modèle par défaut, appuyez sur `d` sur la ligne sélectionnée dans le menu. Cela écrit le champ `model` dans `~/.claude/settings.json`.
Les sessions résumées (`claude --resume`, `--continue`, `/resume`) conservent le modèle utilisé dans la session concernée, indépendamment du réglage actuel. Cela évite qu’une autre session change votre modèle lorsque vous reprenez le travail.
Pour vérifier le modèle actif, utilisez `/status` : la commande affiche le compte et le modèle actuel.
## `/model opusplan` : comparer séparément les coûts de planification et d’exécution
Points clés
`opusplan` est un alias hybride : en Plan Mode, Claude réfléchit avec Opus (architecture, analyse de la tâche) ; dès que Plan Mode est désactivé et que l’exécution réelle commence, Claude passe automatiquement à Sonnet. L’économie dépend des tarifs et des tokens réellement consommés à chaque phase. Dans l’exemple historique ci-dessous, Sonnet à $3/$15 représente 60 % d’Opus à $5/$25 : la réduction est de 40 % sur la portion d’exécution remplacée, pas de 75 à 80 % sur toute la tâche.
Dans la pratique décrite ici, ce mode est utilisé pour les tâches qui prennent plus de 10 étapes.
La logique :
- En Plan Mode (`/plan`), vous discutez de l’architecture et des options et vous convenez d’une approche. Opus coûte cher à cette étape, mais justifie son prix par son raisonnement fondamentalement différent.
- Dès que Plan Mode se termine et que Claude commence à modifier des fichiers, écrire des tests et exécuter des commandes, il s’agit de l’exécution. Pour cette phase, Sonnet 4.6 égale Opus en qualité.
Pour l’activer :
```bash
# Au lancement
claude --model opusplan
# Ou pendant une session
/model opusplan
```
Un calcul précis. Supposons qu’un refactoring de 50 étapes se répartisse habituellement ainsi :
- Planification (5 étapes, ~30,000 tokens en entrée + 8,000 en sortie) : Opus 4.7
- Exécution (45 étapes, ~200,000 tokens en entrée + 50,000 en sortie) : Sonnet 4.6
| Option | Coût de planification | Coût d’exécution | Total |
|----|----|----|----|
| Opus uniquement | \$0.15 + \$0.20 = \$0.35 | \$1.00 + \$1.25 = \$2.25 | **\$2.60** |
| Opusplan (Opus + Sonnet) | \$0.15 + \$0.20 = \$0.35 | \$0.60 + \$0.75 = \$1.35 | **\$1.70** |
La référence consomme 230 000 tokens d’entrée et 58 000 de sortie, soit $2,60 aux tarifs historiques Opus du tableau. Opusplan garde 30 000 entrées et 8 000 sorties sur Opus ($0,35), puis 200 000 entrées et 50 000 sorties sur Sonnet ($1,35), soit $1,70 au total. L’économie vaut ($2,60 − $1,70) / $2,60 = 34,6 %. À comptes identiques, remplacer l’exécution économise 40 % de cette portion ; même si elle pesait 90 % du coût initial, le gain total serait 36 %. Un tokenizer différent exige les comptes explicites par modèle et ne justifie pas seul 75 à 80 %.
⚠️ Un détail : l’Opus en mode plan de `opusplan` utilise le contexte standard de 200K. Le passage automatique à 1M, disponible avec l’alias `opus`, ne s’applique PAS à `opusplan`. Si vous planifiez une tâche volumineuse avec des millions de tokens de contexte (par exemple, l’analyse d’un grand monorepo), utilisez explicitement `/model opus[1m]` ou passez à opusplan APRÈS la planification.
## La commande `/effort` : 5 niveaux de raisonnement adaptatif
Points clés
`/effort` contrôle la profondeur de réflexion du modèle à chaque étape. Les niveaux sont low, medium, high, xhigh (Opus 4.7 uniquement) et max. Depuis la version 2.1.117, les valeurs par défaut sont xhigh pour Opus 4.7 et high pour les autres modèles. low/medium/high/xhigh sont conservés d’une session à l’autre ; max ne s’applique qu’à la session en cours. En low, Opus devient presque aussi rapide et peu coûteux que Sonnet.
C’est la deuxième commande la plus importante après `/model`. Effort désigne le raisonnement adaptatif : à chaque étape, le modèle décide de la profondeur de réflexion nécessaire en fonction de la complexité de la tâche. Plus le niveau est élevé, plus le raisonnement est approfondi et plus le modèle utilise de tokens.
Niveaux (selon la tâche) :
| Niveau | Quand l’utiliser | Ce qui change |
|----|----|----|
| **low** | Tâches courtes sans exigences intellectuelles : renommer des fichiers, recherches grep simples, « que fait cette fonction ? », commande de build | Le modèle réfléchit à peine et répond rapidement et à moindre coût |
| **medium** | Travail où économiser des tokens compte plus qu’une légère perte de précision | Réduit l’utilisation des tokens ; perd parfois en précision sur les nuances |
| **high** | Niveau minimal pour les tâches exigeant un vrai raisonnement : codage, refactoring, revue de code | Équilibre entre tokens et qualité. Valeur par défaut pour Sonnet 4.6 et Opus 4.6 |
| **xhigh** | Meilleurs résultats pour la plupart des tâches de codage et des tâches agentiques | Valeur par défaut pour Opus 4.7. Disponible uniquement sur Opus 4.7 |
| **max** | Tâches très exigeantes. Peut améliorer les résultats, mais tend à faire trop réfléchir le modèle | Pas de limite de tokens. Réinitialisé à la fin de la session |
Trois modèles sont pris en charge : Opus 4.7, Opus 4.6 et Sonnet 4.6. Les autres ne proposent pas le niveau d’effort.
Ce qui a changé en septembre 2026. Les niveaux `low`, `medium`, `high`, `xhigh` et `max` sont disponibles sur Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 et Opus 4.7 ; Opus 4.6 et Sonnet 4.6 ne proposent pas `xhigh`, et une valeur `xhigh` demandée est exécutée comme `high` sur ces modèles. Le niveau par défaut est `high` pour tous les modèles qui prennent en charge effort, à l’exception d’Opus 5.5 (`medium`) et d’Opus 4.7 (`xhigh`). Cela signifie qu’il faut demander explicitement une analyse approfondie au modèle haut de gamme actuel. Un mode séparé, `ultracode`, est également apparu : c’est un réglage de Claude Code, pas un niveau de modèle ; il envoie `xhigh` et demande aussi à Claude de créer des flux de travail dynamiques pour les tâches volumineuses.
Comment le régler :
```bash
# Ouvrir le curseur interactif
/effort
# Définir directement le niveau
/effort high
/effort xhigh
# Revenir au niveau par défaut du modèle
auto
# Avec un indicateur de lancement
claude --effort high
# Avec une variable d’environnement (appliquée au lancement)
export CLAUDE_CODE_EFFORT_LEVEL=high
# Dans les paramètres (max ne fonctionne pas ici — max est limité à la session)
{
"effortLevel": "high"
}
# Dans le frontmatter d’un skill / sous-agent
---
name: my-skill
effort: low
---
```
Le niveau s’affiche à côté du logo et du spinner dans Claude Code, par exemple « avec un effort low » ; il n’est donc pas nécessaire d’ouvrir `/model` pour le vérifier.
Le curseur d’effort apparaît également dans le menu de sélection `/model` : utilisez les flèches gauche/droite pour le régler.
Un détail important. Lorsque vous passez à Opus 4.7 depuis n’importe quel autre modèle, le niveau d’effort est forcé à xhigh, même si vous aviez choisi high pour Opus 4.6 ou Sonnet 4.6. Pour rétablir le niveau souhaité, relancez `/effort`.
Une autre technique : **ultrathink** dans le prompt. Si vous incluez le mot `ultrathink` dans le texte du prompt, Claude approfondira son raisonnement pour ce tour seulement, sans modifier le niveau d’effort de la session. Des expressions similaires (« think », « think hard », « think more ») ne déclenchent pas ce comportement : elles sont simplement transmises comme du texte ordinaire.
## La commande `/fast` : Opus est 2.5 fois plus rapide pour 6 fois le prix — quand est-ce rentable ?
Points clés
`/fast` est une configuration d’API alternative pour les modèles Opus haut de gamme. Ce n’est pas un modèle différent : c’est le même Opus, mais jusqu’à 2.5 fois plus rapide en sortie. Au 23 septembre 2026, cette option est prise en charge sur Opus 5.5, Opus 5 et Opus 4.8 ; elle coûte \$8 / \$40 par million de tokens sur Opus 5.5 et \$10 / \$50 sur Opus 5 et Opus 4.8. Elle n’est pas disponible sur Sonnet ni Haiku, et a été supprimée d’Opus 4.7 le 24 juillet 2026. Elle sert au débogage en direct et au travail interactif lorsque la latence compte davantage que le coût.
Le mode rapide est une fonctionnalité en aperçu de recherche. Il nécessite Claude Code v2.1.36+ ; vous pouvez vérifier la version avec `claude --version`.
Pour l’activer :
```bash
# Activer ou désactiver le mode rapide (disponible dans la CLI Claude Code et l’extension VS Code)
/fast
# Ou dans les paramètres
{
"fastMode": true
}
```
Après son activation :
- Si vous utilisez un autre modèle, Claude Code passe automatiquement à Opus.
- Une confirmation « Fast mode ON » apparaît.
- Une icône `↯` apparaît à côté du prompt.
Options et détails :
- Le modèle par défaut du mode rapide est l’Opus disponible le plus performant. Au 23 septembre 2026, il s’agit d’Opus 5.5 ; le mode rapide ne fonctionne pas du tout avec Opus 4.7, et basculer sur celui-ci désactive le mode rapide.
- Le mode rapide est conservé entre les sessions par défaut. Les administrateurs Team/Enterprise peuvent exiger une activation explicite pour chaque session avec `fastModePerSessionOptIn: true`.
- Si vous désactivez le mode rapide en exécutant de nouveau `/fast`, vous restez sur Opus : le modèle ne revient pas à celui qui était utilisé auparavant. Pour changer de modèle, utilisez `/model`.
- Si vous l’activez au milieu d’une conversation, le tarif du mode rapide s’applique à tout le contexte de la conversation. Il est donc plus économique d’activer le mode rapide au tout début d’une session, plutôt qu’à mi-parcours.
Quand utiliser le mode rapide :
- **Débogage en direct** : vous suivez une trace et le temps de réponse est crucial.
- **Échéance serrée pour du travail interactif** : vous préparez une démo pour 18:00 et avez besoin d’itérations rapides.
- **Itération rapide sur le code** : vous testez des hypothèses les unes après les autres.
Quand ne pas l’utiliser :
- **Longues tâches autonomes** où la vitesse n’est pas essentielle. Vous payez 6 fois plus pour une vitesse multipliée par 2.5 : cela ne vaut pas le coup si vous partez déjeuner pendant que Claude travaille.
- **Traitement par lots, pipelines CI/CD** — ce n’est pas du tout un mode interactif.
- **Charges sensibles aux coûts** — le choix est évident.
Disponibilité :
- Ne fonctionne PAS sur Bedrock, Vertex ou Foundry.
- Nécessite des **crédits d’utilisation** sur le compte (facturation au-delà de la limite incluse dans l’offre). Pour les comptes individuels, l’option s’active dans les paramètres de facturation de la Console. Pour Team/Enterprise, un administrateur doit l’activer.
- Les tokens du mode rapide ne sont PAS déduits de la limite incluse dans l’offre. Ils sont directement facturés sur les crédits d’utilisation, au tarif du mode rapide dès le premier token.
Si vous atteignez la limite de requêtes du mode rapide ou n’avez plus de crédits d’utilisation, le mode rapide revient automatiquement à la vitesse et aux tarifs standards, l’icône `↯` devient grise et le travail continue. Lorsque la limite est réinitialisée, le mode rapide se réactive.
Le mode rapide et effort ne sont pas des réglages incompatibles. Vous pouvez les combiner : mode rapide + low effort = vitesse maximale pour les tâches simples.
## Combien coûte réellement chaque modèle : détail de votre facture mensuelle
Points clés
Tarifs de base par million de tokens : Haiku 4.5 — \$1 / \$5, Sonnet 4.6 — \$3 / \$15, Opus 4.7 — \$5 / \$25. Mode rapide — \$30 / \$150. La mise en cache des prompts réduit à 0.1x le coût des entrées répétées. L’API Batch offre 50 % de réduction. La principale source d’économies n’est pas le modèle lui-même, mais le fait d’éviter Opus quand Sonnet suffit.
Tarifs par million de tokens (API Anthropic, USD) :
| Modèle | Entrée | Écriture du cache à 5 min | Écriture du cache à 1 heure | Lecture du cache | Sortie |
|------------------|-------|-------------------|-----------------|-----------|--------|
| Haiku 4.5 | \$1 | \$1.25 | \$2 | \$0.10 | \$5 |
| Sonnet 4.6 | \$3 | \$3.75 | \$6 | \$0.30 | \$15 |
| Opus 4.6 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Opus 4.7 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Mode rapide (Opus) | \$30 | n/a | n/a | n/a | \$150 |
Ce qui réduit réellement la facture :
1. **Mise en cache des prompts.** Anthropic met en cache les sections répétées des prompts : le prompt système, CLAUDE.md, les descriptions des outils. Une lecture du cache coûte 10 % du prix d’entrée. Avec Sonnet, cela fait passer \$3 par million de tokens à \$0.30, soit un coût dix fois moindre. La fonction s’active automatiquement dans la requête API avec `cache_control: { type: "ephemeral" }`. Dans Claude Code, elle fonctionne par défaut.
2. **API Batch** : 50 % de réduction sur l’entrée et la sortie pour les tâches dont vous pouvez attendre le résultat (rapports, génération de textes en masse par lots). Avec l’API Batch, Sonnet coûte \$1.50 / \$7.50. Cette fonction n’est pas disponible directement dans Claude Code, mais utilisez-la si vous créez des automatisations avec le SDK Anthropic.
3. **opusplan au lieu d’Opus seul** : environ 34,6 % dans l’exemple historique ; le total réel dépend de l’exécution, des tokens, tarifs, cache et nouvelles tentatives.
4. **Sonnet par défaut + Opus en cas de besoin** : la principale source d’économies. Si Opus est activé « au cas où », la pratique décrite ici consiste à passer à Sonnet. Si la tâche nécessite Opus, cela devient évident à la troisième ou quatrième étape, et je passe explicitement à `/model opus`.
5. **N’oubliez pas le nouveau tokenizer d’Opus 4.7.** Sur le même fichier, Opus 4.7 utilise jusqu’à 35 % de tokens en plus que Sonnet 4.6. Le coût réel de la même tâche augmente davantage que ne le laisse penser le tableau.
Un exemple concret : une tâche type pour une agence immobilière qui crée le prototype de site Web d’un nouveau client : « crée une page avec trois sections, un formulaire et l’intégration d’une passerelle de paiement ». Les résultats :
- Opus 4.7 seul (effort high) : ~\$4.80 par session (1.5 heure de travail).
- opusplan : ~\$1.90 (Opus planifie, Sonnet exécute).
- Sonnet 4.6 seul (effort high) : ~\$1.30, mais la décision architecturale était moins bonne (Sonnet a choisi une approche fondée sur un modèle, tandis qu’Opus en mode opusplan a trouvé une approche adaptée aux exigences non standard).
Pour cette tâche, opusplan l’emporte. Les économies sont de 60 %, avec la qualité d’Opus pour la partie essentielle.
Claude Code n’affiche pas directement le nombre de tokens consommés par les limites : celles-ci sont dynamiques et dépendent de l’offre. En revanche, `/status` indique votre offre et votre consommation actuelle. Pour un suivi plus précis, consultez le guide détaillé : [Comment éviter d’épuiser les limites de Claude Code en une journée](https://ailoot.ai/blog/fr/claude-code-token-limits-saving/).
## Quel flux de travail quotidien mettre en place ? 4 préréglages prêts à l’emploi
Points clés
Quatre préréglages pour différents types de tâches. Codage quotidien — Sonnet + effort high. Refactoring lourd — opusplan. Correction rapide — Haiku + effort low. Session d’architecture — Opus 4.7 + effort xhigh + Plan Mode. Vous pouvez enregistrer chacun comme alias, l’associer à un skill ou simplement le garder à portée de main comme première commande au démarrage d’une session.
Ces quatre préréglages peuvent être sélectionnés selon la journée de travail et la tâche.
**Préréglage 1. Codage quotidien — 80 % du temps de travail dans la pratique décrite ici.**
```bash
claude --model sonnet --effort high
# Dans la session, passer à Opus si nécessaire
/model opus
```
Usage : nouvelles fonctionnalités, petits refactorings, débogage de bugs simples, documentation. Sonnet avec effort high est le meilleur compromis.
**Préréglage 2. Refactoring lourd — une évolution architecturale majeure.**
```bash
claude --model opusplan
# Commencer par discuter de la structure avec /plan
# Après avoir quitté Plan Mode, Sonnet s’occupe de l’exécution
```
Usage : réécriture d’un module réparti sur plus de 15 fichiers, migration d’une intégration d’une passerelle à une autre. Opus s’occupe de l’architecture (analyse des dépendances) et Sonnet de l’exécution (modification rapide des fichiers). Ces tâches peuvent permettre d’économiser plus de 70 %.
**Préréglage 3. Correction rapide — modifications d’une ligne et scripts.**
```bash
claude --model haiku --effort low
```
Usage : « change le nom d’une variable dans tous les fichiers », « écris un script bash pour redémarrer nginx », « que fait cette fonction ? » Haiku gère ces tâches et coûte trois fois moins cher que Sonnet.
**Préréglage 4. Session d’architecture — une décision stratégique.**
```bash
claude --model opus --effort xhigh
# Utiliser l’effort maximal en passant à Plan Mode :
/plan
# Ajouter le mot ultrathink au prompt pour les questions cruciales
```
Usage : « X doit-il être un service distinct ? », « quels outils utiliser pour le prototype ? », « comment organiser un schéma de base de données pour une utilisation multi-tenant ? » Opus 4.7 coûte cher ici — et cela en vaut la peine, car une erreur à ce stade coûte des semaines de travail.
Vous pouvez enregistrer ces préréglages comme skills (un modèle par skill) ou comme alias dans `~/.zshrc` :
```bash
alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'
```
Si vous travaillez en équipe, vous pouvez standardiser les choix au moyen des paramètres gérés. Un administrateur définit `availableModels: ["sonnet", "haiku", "opusplan"]` dans la politique de l’organisation, et les utilisateurs ne peuvent physiquement pas choisir Opus directement, seulement avec une autorisation explicite. C’est une bonne protection contre l’épuisement accidentel de la limite.
Pour ceux qui créent des [sous-agents](https://ailoot.ai/blog/fr/claude-code-subagents/), vous pouvez également définir des modèles différents pour chaque sous-agent via `CLAUDE_CODE_SUBAGENT_MODEL` ou le champ `model` dans le frontmatter de sa définition. Cela ajoute un autre niveau d’optimisation.
## Que faire lorsque vous manquez de capacité : 5 techniques pratiques
Points clés
Quand vous atteignez la limite Opus, ne paniquez pas. Cinq façons de continuer à travailler : passer à Sonnet, utiliser opusplan, activer la mise en cache des prompts, transférer une partie du travail vers l’API Batch ou passer à Haiku pour les tâches secondaires. Les limites ont été doublées en mai 2026 et la limitation aux heures de pointe a été supprimée, ce qui rend l’épuisement de la capacité Opus plus difficile.
Si `/status` indique que vous avez atteint la limite Opus :
1. **Passez à Sonnet 4.6** : `/model sonnet`. Il dispose d’un pool séparé, et vous ne remarquerez pas de différence pour 80 % des tâches. Avec l’API Anthropic, même lorsque vous atteignez la limite Opus, Claude Code peut passer automatiquement à Sonnet si vous approchez du seuil.
2. **Utilisez opusplan pour le travail restant** : `/model opusplan`. S’il vous reste des tâches en Plan Mode pour la journée, elles utiliseront très peu Opus (uniquement pour la planification) ; l’exécution se fera entièrement avec Sonnet.
3. **Vérifiez la mise en cache des prompts** : assurez-vous de ne pas l’avoir désactivée avec `DISABLE_PROMPT_CACHING=1`. Si votre CLAUDE.md ou votre prompt système contient un mégaoctet de paramètres, il devrait être mis en cache. Avec 90 % de lectures, cela réduit la consommation d’un facteur dix.
4. **Déplacez les tâches par lots** : si vous avez des générations en masse (rapports, textes, traductions), déplacez-les vers un script utilisant l’API Batch : 50 % de réduction sur l’entrée et la sortie. Elle n’est pas disponible directement dans Claude Code, mais sa mise en place prend 30 minutes avec un script `tsx` + le SDK Anthropic.
5. **Utilisez Haiku pour les tâches secondaires** : pour les tâches courantes comme « écris un message de commit » ou « explique ce que fait ce fichier », passez Claude Code à Haiku. Il consomme trois fois moins que Sonnet et cinq fois moins qu’Opus.
Et le principal rappel : **depuis le 6 mai 2026, les limites de Pro, Max, Team et Enterprise ont été doublées**, et la limitation aux heures de pointe a été supprimée. Si Opus épuise votre capacité en une demi-journée, le problème ne vient pas des limites : Opus est utilisé là où Sonnet suffirait. La carte de décision dans la deuxième section de ce guide vous permet de reprendre le contrôle.
Pour approfondir les limites et découvrir huit règles pratiques pour économiser des tokens, consultez cet article de référence : [Comment éviter d’épuiser les limites de Claude Code en une journée : 8 règles pour économiser des tokens en 2026](https://ailoot.ai/blog/fr/claude-code-token-limits-saving/). Un autre guide utile est [Plan Mode dans Claude Code : guide pas à pas](https://ailoot.ai/blog/fr/claude-code-plan-mode/), car opusplan ne fonctionne pas sans Plan Mode. Enfin, la base de chaque modèle est [Comment configurer CLAUDE.md en 2026](https://ailoot.ai/blog/fr/claude-md-template/).
### Sources
- [Anthropic — Annonce de Claude Opus 5.5 (22 septembre 2026)](https://www.anthropic.com/news/claude-opus-5-5)
- [API Anthropic : présentation des modèles, tarifs et niveaux d’effort](https://platform.claude.com/docs/en/about-claude/models/overview)
- [Anthropic Claude Code : configuration du modèle](https://code.claude.com/docs/en/model-config)
- [Anthropic Claude Code : accélérer les réponses avec le mode rapide](https://code.claude.com/docs/en/fast-mode)
- [Anthropic Claude Code : nouveautés](https://code.claude.com/docs/en/whats-new)
- [API Anthropic : tarifs](https://platform.claude.com/docs/en/about-claude/pricing)
- [API Anthropic : niveaux d’effort](https://platform.claude.com/docs/en/build-with-claude/effort)
- [API Anthropic : fenêtre de contexte de 1M tokens](https://platform.claude.com/docs/en/build-with-claude/context-windows)
- [Assistance Anthropic : modèles, utilisation et limites dans Claude Code](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Blog Anthropic : nouveautés de Claude Managed Agents (Code with Claude 2026)](https://claude.com/blog/new-in-claude-managed-agents)
Autres ressources et outils : [Ailoot](https://ailoot.ai/).
## Questions fréquentes : Sonnet, Opus et effort dans Claude Code : choisir un modèle
### Combien l’exemple opusplan économise-t-il ?
Aux tarifs et comptes historiques du tableau, Opus seul coûte $2,60 et opusplan $1,70. Le gain de $0,90 / $2,60 représente environ 34,6 %, sans démontrer une économie universelle de 75 à 80 %.
### Un modèle d’exécution moins cher garantit-il une tâche réussie moins chère ?
Non. Utilisez les comptes réels d’entrée, sortie, cache et nouvelles tentatives aux tarifs applicables, avec les mêmes contrôles de réussite. Le tarif unitaire n’est qu’une partie du coût final.
## Ailoot · L’entreprise et son portefeuille de projets
Ailoot s’appuie sur une expérience opérationnelle éprouvée, une large clientèle, un service stable et un suivi continu des KPI.
L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.
Ailoot met cette expérience opérationnelle au service de l’accès API aux fonctions d’IA dans les produits des clients, leurs agents, applications et automatisations.