TL;DR
- Sonnet 4.5 est le modèle Anthropic sorti fin septembre 2025. Il se positionne comme le meilleur modèle du monde pour les agents et le code.
- En pratique, le gain par rapport a Sonnet 4 est surtout visible sur les taches agentiques longues : planification, execution multi-etapes, correction automatique.
- Le rapport vitesse/qualite est excellent : plus rapide qu'Opus 4.1 pour 90% des taches, et seulement marginalement moins bon sur le raisonnement pur.
- Le pricing reste agressif : pour du code quotidien, c'est le sweet spot entre Haiku et Opus.
- Mon conseil : Sonnet 4.5 pour le dev quotidien, Opus 4.1 pour l'architecture et les decisions complexes.
Le contexte de la sortie
Fin septembre 2025, Anthropic sort Sonnet 4.5. Pas de keynote grandiose, pas de hype artificielle -- juste un billet de blog et un modele disponible dans l'API. Le message est clair : "best model in the world for real-world agents and coding."
C'est une affirmation audacieuse. Et apres deux semaines d'utilisation intensive, je vais te donner mon avis honnete.
Pour situer : j'utilisais deja Claude Code avec Sonnet 4 et Opus 4.1 au quotidien. Mon workflow repose sur un agent qui planifie, code, teste et corrige en boucle. Le modele sous-jacent, c'est le moteur de tout ca. Un meilleur modele, c'est un meilleur binome.
Premieres impressions : la vitesse frappe d'abord
La premiere chose que tu remarques avec Sonnet 4.5, c'est la vitesse. Pas la qualite du raisonnement, pas la precision du code -- la vitesse. Les reponses arrivent sensiblement plus vite qu'avec Opus 4.1, et le temps de "reflexion" avant de commencer a generer est reduit.
Pourquoi c'est important ? Parce que dans un workflow agentique, le modele ne repond pas une seule fois. Il repond 10, 20, 50 fois dans une boucle. Chaque seconde de latence se multiplie. Un modele 30% plus rapide, c'est un workflow 30% plus rapide. Et ca change tout.
Sur mes tests concrets :
- Refactoring multi-fichiers (10 fichiers TypeScript) : Sonnet 4.5 finit en ~45 secondes. Opus 4.1 prenait ~70 secondes.
- Debug d'une erreur complexe (stack trace + 5 fichiers a lire) : Sonnet 4.5 identifie la cause en 2 iterations. Opus 4.1 en 2 aussi, mais chaque iteration prend plus de temps.
- Generation de tests : vitesse comparable, qualite comparable.
Le gain n'est pas revolutionnaire sur une seule requete. Mais sur une session de 2 heures de dev avec un agent, tu gagnes facilement 20-30 minutes.
La qualite du code : des progres reels
Sonnet 4 avait un probleme recurrent : il generait du code qui "marchait" mais qui n'etait pas idiomatique. Des patterns React obsoletes, des types TypeScript trop permissifs, des tests qui testaient l'implementation plutot que le comportement.
Sonnet 4.5 corrige ca en grande partie. Le code genere est plus propre, les types sont plus precis, et surtout les tests sont plus pertinents. Ce n'est pas magique -- tu dois toujours relire et corriger. Mais le ratio "code utilisable tel quel / code a retravailler" s'est nettement ameliore.
Un exemple concret. J'ai demande a Sonnet 4 et Sonnet 4.5 la meme chose : "cree un hook React pour gerer la pagination cote serveur avec support du cache." Sonnet 4 m'a donne un hook fonctionnel mais avec des useEffect mal structures et un state management fragile. Sonnet 4.5 m'a donne un hook avec useSWR, de la deduplication de requetes, et du cache invalidation propre. La difference de maturite est visible.
L'agentique : le vrai terrain de jeu
C'est la ou Sonnet 4.5 brille le plus. Un LLM utilise comme agent doit faire trois choses bien :
- Planifier : decomposer un objectif en etapes coherentes
- Executer : appliquer chaque etape sans devier
- Corriger : detecter ses propres erreurs et ajuster
Sonnet 4.5 excelle sur les trois. La planification est plus structuree -- il decoupe mieux les taches complexes en sous-taches independantes. L'execution est plus fiable -- moins de "je modifie un fichier mais j'oublie de mettre a jour l'import." La correction est plus rapide -- il identifie la cause d'un echec de test en moins d'iterations.
Le resultat pratique : des sessions Claude Code ou je dois intervenir moins souvent. Au lieu de superviser chaque etape, je peux donner un objectif plus large et laisser l'agent travailler. Ce n'est pas de l'autonomie totale -- c'est encore loin. Mais c'est un cran au-dessus de ce qu'on avait.
Sonnet 4.5 vs Opus 4.1 : quand utiliser quoi
C'est la question que tout le monde pose. Voici ma reponse apres deux semaines :
| Critere | Sonnet 4.5 | Opus 4.1 |
|---|---|---|
| Vitesse | Rapide | Lent |
| Code generation | Excellent | Excellent+ |
| Raisonnement complexe | Tres bon | Superieur |
| Taches agentiques | Excellent | Bon |
| Architecture/design | Bon | Excellent |
| Prix | Moyen | Eleve |
Mon workflow :
- Sonnet 4.5 : dev quotidien, refactoring, tests, debug, taches agentiques longues
- Opus 4.1 : decisions d'architecture, analyse de code complexe, revue de design, problemes necessitant un raisonnement en profondeur
En pratique, 80% de mon temps est sur Sonnet 4.5. Opus 4.1 intervient pour les moments ou je sens que le modele "ne comprend pas le probleme de fond" -- et ca arrive moins souvent qu'on ne le pense.
Le pricing : le sweet spot
C'est un aspect sous-estime. Dans un workflow agentique, tu consommes beaucoup de tokens. Beaucoup. Une session de debug un peu longue peut facilement atteindre 100K tokens en input/output cumules.
Sonnet 4.5 se positionne entre Haiku et Opus en termes de cout par token. Pour la qualite delivree, c'est un excellent rapport qualite-prix. Tu paies plus qu'avec Haiku, mais la difference de qualite justifie largement le surcout sur des taches de dev. Tu paies moins qu'Opus, et pour 80% des cas d'usage tu ne vois pas la difference.
Pour un dev solo qui utilise l'API directement, le budget mensuel est tenable. Pour une equipe qui deploie des agents en production, le pricing de Sonnet 4.5 rend des cas d'usage viables qui ne l'etaient pas avec Opus.
Les limites -- soyons honnetes
Sonnet 4.5 n'est pas parfait. Voici ce qui m'a frustre :
Le contexte long reste un probleme. Sur des sessions agentiques tres longues (>150K tokens de contexte), le modele commence a "oublier" des instructions donnees au debut. C'est un probleme de tous les LLM, pas specifique a Sonnet 4.5, mais ca reste frustrant.
Les hallucinations sur les API. Il invente encore des noms de fonctions qui n'existent pas. Moins que Sonnet 4, mais ca arrive. Surtout sur des librairies moins populaires.
L'exces de confiance. Quand Sonnet 4.5 se trompe, il se trompe avec assurance. Il ne dit pas "je ne suis pas sur." Il genere du code incorrect avec le meme aplomb que du code correct. C'est un piege classique des bons modeles : leur confiance te rend moins vigilant.
Le verdict
Sonnet 4.5, c'est le modele que j'attendais pour mon workflow quotidien. Pas parce qu'il est revolutionnaire -- c'est une evolution, pas une revolution. Mais parce qu'il atteint le bon equilibre entre vitesse, qualite et cout.
Si tu utilises deja Claude Code ou un workflow agentique similaire, la mise a jour vers Sonnet 4.5 est un no-brainer. Si tu hesites encore entre un modele "premium" et un modele "rapide", Sonnet 4.5 elimine le dilemme : c'est les deux a la fois, pour la majorite des taches.
Le vrai changement, ce n'est pas le modele en soi. C'est ce qu'il permet en termes de workflow. Un modele plus rapide et plus fiable, c'est un agent plus autonome. Et un agent plus autonome, c'est un dev qui passe plus de temps sur les problemes interessants.
C'est ca, la promesse de Sonnet 4.5. Et pour une fois, elle est tenue.
Ressources
- Annonce officielle Sonnet 4.5 -- le billet de blog d'Anthropic
- Claude API Documentation -- pour tester toi-meme
- Mon article sur les agents IA -- pour comprendre le workflow agentique
- SWE-bench Results -- benchmarks de coding sur des vraies issues GitHub
