Il existe un type de réunion bien particulier qui se tient dans chaque équipe bâtissant sur des LLM de pointe. Quelqu’un partage le dernier classement des benchmarks. Quelqu’un d’autre souligne que le classement a été chamboulé depuis le mois dernier. Une troisième personne note que le modèle qu’ils utilisent actuellement a glissé de deux places sur une métrique dont aucun d’eux n’avait entendu parler il y a trois semaines. À la fin de la réunion, personne ne sait s’il faut migrer, et la discussion est reprogrammée au trimestre prochain.
Le problème de cette réunion ne vient pas des personnes présentes. C’est que les benchmarks mesurent des tâches synthétiques, et votre produit n’est pas une tâche synthétique. Le classement vous dit comment un modèle se comporte sur MMLU, sur SWE-bench Verified, sur GPQA Diamond — des tests conçus par des chercheurs pour être mesurables à travers les modèles. Aucun de ces tests ne ressemble aux invites que votre application envoie réellement en production. Aucun ne capture la manière dont un modèle gère le type précis d’entrée brouillonne et spécifique à votre domaine que vos utilisateurs génèrent.
Cet article décrit exactement l’exercice que les benchmarks ne peuvent pas faire. Trois invites concrètes, conçues pour être envoyées à GPT-5.5, Claude Sonnet 4.6 et Gemini 3.1 Pro via le même point de terminaison compatible OpenAI, avec les mêmes réglages de température et sans incitation supplémentaire. Les invites couvrent trois catégories qui touchent la plupart des charges de production : extraction structurée à partir d’un document brouillon, une tâche de planification à forte exigence de raisonnement, et génération de code sous contraintes. Les observations ci-dessous sont les schémas comportementaux que les équipes menant ce type de comparaison rapportent systématiquement — les schémas que vous verriez vous-même si vous exécutiez ces invites sur votre propre configuration.
Sur les classements, ces trois modèles se tiennent à 0.8 point de pourcentage d’écart sur SWE-bench Verified. En pratique, ils se comportent très différemment. Le choix entre eux ne porte pas sur celui qui obtient la meilleure note aux benchmarks — il porte sur le schéma comportemental qui correspond à votre charge.
Ce que les benchmarks mesurent, et ce qu’ils manquent
Les benchmarks existent parce qu’ils sont nécessaires. Les fournisseurs de modèles ont besoin de tests standardisés pour étayer leurs affirmations de capacité, les chercheurs en ont besoin pour publier des comparaisons, et le reste d’entre nous en a besoin pour disposer d’un point de départ objectif pour évaluer les modèles. Ils sont utiles. Ils sont aussi incomplets de manières qui comptent pour l’usage en production.
Trois limites spécifiques méritent d’être explicitées, car chacune se retrouve dans les exemples d’invite ci-dessous.
- Les benchmarks mesurent des capacités isolées, pas des schémas comportementaux. SWE-bench Verified vous dit si un modèle peut résoudre un certain type de ticket GitHub. Il ne vous dit pas si le modèle a tendance à sur‑concevoir des problèmes simples, s’il pose des questions de clarification lorsque l’invite est ambiguë, ou s’il produit dès le premier essai une sortie respectant la structure demandée. Ce sont des éléments que vous observerez quotidiennement en production.
- Les benchmarks sont l’objet d’ajustements. Lorsqu’une version de modèle met en avant son score sur un benchmark particulier, c’est le signe que le modèle a été au moins partiellement optimisé pour ce benchmark. La performance en conditions réelles et la performance au benchmark peuvent diverger — parfois considérablement — dès que le modèle sort des conditions pour lesquelles le benchmark a été conçu.
- Les benchmarks agrègent. Un écart de 0.8 point de pourcentage sur SWE-bench Verified peut masquer le fait que le Modèle A est bien meilleur sur une catégorie de tâches spécifique et moins bon sur une autre, tandis que le Modèle B est homogène partout. L’agrégation écrase des informations dont vous avez besoin pour décider.
L’exercice ci-dessous est conçu pour faire émerger précisément le type d’information que les benchmarks agrègent. Le but n’est pas de déclarer un gagnant — c’est de montrer les questions que vous devriez vous poser lorsque vous menez le même exercice sur vos propres invites.
La configuration
Trois invites, choisies parce qu’elles correspondent à des catégories couvrant la plupart des charges de production. La configuration : chaque invite est envoyée aux trois modèles avec des paramètres identiques (température 0.3, pas de remplacement du système prompt, format de réponse par défaut), accessibles via un seul point de terminaison compatible OpenAI pour que la comparaison reste homogène — pas de bizarreries propres aux SDK des fournisseurs, pas de différences de mappage de paramètres, pas de risque qu’un modèle bénéficie d’un traitement de faveur à cause de la construction de la requête.
Les invites elles‑mêmes figurent ci‑dessous, sous forme de blocs de code que vous pouvez copier et exécuter. Les descriptions comportementales qui suivent chacune sont les schémas que les équipes rapportent systématiquement lors de ce type de comparaison — des schémas documentés dans de multiples études tierces en 2026, et le genre de choses auxquelles vous devriez vous attendre lorsque vous exécutez ces invites sur votre propre configuration. L’exécuter vous‑même est l’objectif ; l’article vous donne le cadre et les invites de départ pour le faire.
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ["COMET_API_KEY"], # or replace with your API key
base_url="https://api.cometapi.com/v1", # one endpoint, multiple models
)
MODELS = [
"gpt-5.5",
"claude-sonnet-4-6",
"gemini-3.1-pro",
]
def run_comparison(prompt: str, temperature: float = 0.3) -> dict[str, str]:
"""
Send the same prompt to all three models and return their responses.
"""
responses = {}
for model in MODELS:
result = client.chat.completions.create(
model=model,
messages=[
{
"role": "user",
"content": prompt,
}
],
temperature=temperature,
)
responses[model] = result.choices[0].message.content
return responses
# Example usage
if __name__ == "__main__":
prompt = "Summarise the key risks in this contract."
outputs = run_comparison(prompt)
for model, response in outputs.items():
print(f"\n--- {model} ---")
print(response)
Invite 1 : Extraction structurée depuis un document brouillon
C’est la tâche de base de la moitié des fonctionnalités LLM livrées en 2026. Prendre une entrée non structurée — un e‑mail, un ticket de support, un compte‑rendu de réunion, un formulaire scanné — et en extraire des champs spécifiques dans un objet structuré. L’invite ci‑dessous demande à chaque modèle d’extraire sept champs d’un e‑mail de support client volontairement brouillon contenant des informations partielles, des signaux contradictoires, et un champ qui n’est pas présent du tout dans la source.
L’invite
You are processing customer support emails. Extract the followingseven fields from the email below into a JSON object with exactlythese keys: - customer_name (string)- order_id (string)- issue_type (one of: "shipping", "product_quality", "billing", "returns", "other")- urgency (one of: "low", "medium", "high")- requested_action (string)- affected_product (string)- escalation_history (any prior contact about this issue, if mentioned)
Email:---Hi there, I'm writing about order #FT-2289334 from last Tuesday. The Cascadehiking boots I received are NOT the size 11 I ordered — they'reclearly size 10 (I can see the label inside). I have a guided trekbooked in 5 days and I genuinely don't know what to do. I've beena customer for years and this is the first time something likethis has happened. Can you sort this out urgently? I'd prefer a same-day exchange ifat all possible. I'm in Manchester. Margaret W.--- Return only the JSON object. No commentary, no markdown code fences.
À surveiller
Trois choses. D’abord, si le modèle respecte le schéma JSON demandé sans invention. Ensuite, comment le modèle gère le champ absent de la source (escalation_history — la cliente ne mentionne aucun contact préalable à propos de ce problème) — admet‑il l’absence ou fabrique‑t‑il quelque chose de plausible ? Enfin, si le modèle produit des commentaires en dehors du JSON, imposant un post‑traitement en aval pour enlever l’enveloppe. Le champ d’urgence mérite aussi attention : « 5 days » n’est pas immédiat, mais la cliente est clairement anxieuse, ce qui laisse place à l’interprétation.
Ce que les équipes rapportent systématiquement
GPT-5.5. Produit généralement du JSON propre dès le premier essai. Le respect du schéma est solide ; chaque champ demandé est présent, et le format est analysable sans pré‑traitement. Pour les champs manquants, GPT-5.5 a tendance à renvoyer un null explicite. Il n’entoure généralement pas le JSON de blocs de code markdown et n’inclut pas d’explication, ce qui rend le traitement en aval trivial. Sur des arbitrages ambigus comme la cote d’urgence ici, GPT-5.5 a tendance à être plus conservateur que les deux autres — là où Claude et Gemini pourraient classer le ticket « high » en se basant sur le ton émotionnel de la cliente, GPT-5.5 s’ancre souvent sur la fenêtre concrète de 5 jours et opte pour « medium ».
Claude Sonnet 4.6. Produit aussi du JSON propre et est généralement le plus précis des trois dans le respect du schéma demandé. Là où GPT-5.5 laisse un champ manquant à null, Claude ajoute souvent des champs non demandés signalant des problèmes de qualité des données — une clé « notes » ou « data_quality_notes » non demandée mais contenant des informations réellement utiles. Ce champ supplémentaire est utile pour des relecteurs humains mais provoque des échecs si votre parseur en aval est strict sur le schéma. C’est un motif récurrent avec Claude : une qualité élevée, mais parfois plus exhaustif que l’invite ne l’exige, nécessitant des instructions explicites pour contraindre.
Gemini 3.1 Pro. Produit généralement la sortie la plus économique des trois. Tous les champs demandés, pas de champs supplémentaires, pas de prose autour. Le respect du schéma est exactement conforme à la demande. Une particularité à connaître : pour les champs manquants, Gemini a tendance à renvoyer une chaîne vide plutôt que null. Les parseurs JSON stricts qui distinguent les deux détecteront la différence ; les parseurs plus tolérants non. Le comportement est suffisamment constant d’un run à l’autre pour sembler être une préférence du modèle plutôt qu’un artefact.
Ce que cela vous apprend
Les trois modèles peuvent faire de l’extraction structurée. Les différences se situent dans la marge comportementale autour du schéma demandé. Si votre système en aval est strict sur le schéma et traite les champs supplémentaires comme des erreurs, Gemini 3.1 Pro et GPT-5.5 sont des choix plus sûrs. Si vous voulez que le modèle fasse remonter les problèmes de qualité des données sans qu’on le lui demande, Claude Sonnet 4.6 est plus utile. Rien de cela n’apparaît dans un benchmark.
Invite 2 : Une tâche de planification exigeant beaucoup de raisonnement
Cette invite demande aux modèles de planifier une enquête multi‑étapes : une question de recherche avec trois contraintes implicites qu’un modèle soigneux devrait identifier avant de séquencer le travail. Le genre de tâche qu’une application agentique déléguerait à un LLM comme étape de planification avant d’invoquer des outils.
L’invite
I'm trying to answer this research question for my team: "Is our customer churn rate higher among users who haven't usedfeature X in the last 30 days?" Produce a plan for how to investigate this. The plan should:- Identify the steps required- Sequence them with dependencies- Be actionable for a data analyst on my team Return the plan in clear, structured form.
Les contraintes implicites à surveiller : la question ne définit jamais ce que « churn » signifie (fermeture de compte ? aucune connexion ? aucun achat ?), elle ne précise pas comment contrôler les variables confondantes (les utilisateurs peu engagés churnent pour de nombreuses raisons sans lien avec la fonctionnalité X), et elle n’établit pas de groupe de comparaison de référence. Un planificateur soigneux devrait faire ressortir ces trois éléments avant de proposer les étapes.
À surveiller
Si le modèle raisonne vraiment sur le problème ou s’il produit une séquence d’étapes qui a l’air plausible mais ne tient pas la route à l’examen. S’il identifie les contraintes implicites sans qu’on les lui dise. Et si les dépendances entre les étapes sont correctes — un plan qui semble bon mais avec une étape trois dépendant d’un résultat de l’étape cinq est inutilisable en pratique.
Ce que les équipes rapportent systématiquement
GPT-5.5. Produit généralement le plan le plus exploitable opérationnellement. Le raisonnement tend à être visible — GPT-5.5 énumère ses hypothèses sur les contraintes implicites (définition du churn, groupe de contrôle, variables confondantes) avant d’énoncer les étapes, ce qui permet de repérer facilement où son interprétation diffère de l’intention. Les dépendances d’étapes sont fidèlement identifiées et étiquetées. La sortie inclut souvent une section signalant quelles étapes peuvent être parallélisées, ce qui n’était pas demandé mais apporte une réelle valeur. C’est le type de tâche où l’entraînement à l’usage d’outils et aux approches agentiques de GPT-5.5 se voit — le comportement de planification suppose que l’exécution en aval suivra.
Claude Sonnet 4.6. Produit généralement le plan le plus réfléchi, au sens propre — le plan de Claude inclut souvent des considérations que les deux autres modèles ne soulèvent pas. Sur une question comme celle‑ci, Claude est susceptible de signaler le problème méthodologique corrélation vs causalité, de noter que « n’ont pas utilisé la fonctionnalité X » pourrait être un symptôme du churn plutôt qu’une cause, et d’identifier explicitement des contraintes non formulées qu’un analyste soigneux devrait repérer. Le revers : le plan peut être plus long que nécessaire, et certaines étapes parfois sur‑conçues par rapport à la question. Motif cohérent avec le comportement de Claude ailleurs — souci d’expert, parfois au‑delà de ce que la tâche exige.
Gemini 3.1 Pro. Produit généralement le plan le plus proprement structuré, avec le graphe de dépendances le plus clair. La qualité du raisonnement est élevée — Gemini identifie de façon fiable les contraintes implicites, décompose le problème en une séquence défendable, et fournit des instructions pas à pas réellement exécutables. L’inconvénient : le plan peut paraître un peu mécanique. Il fait le travail mais a tendance à ne pas faire émerger les subtilités méthodologiques que Claude souligne, ni les idées de parallélisation que GPT-5.5 inclut. Cela correspond au motif plus large de Gemini — fort en qualité de raisonnement, plus « applicatif » sur les jugements périphériques.
Ce que cela vous apprend
La qualité du raisonnement sur cette tâche est élevée pour les trois modèles. Les différences résident dans le comportement périphérique — ce que le modèle ajoute au‑delà de la demande littérale. GPT-5.5 ajoute du pragmatisme opérationnel (parallélisation, conseils d’exécution). Claude ajoute un soin d’expert (méthodologie, cas limites, nuances statistiques). Gemini ajoute clarté et économie. Aucun de ces choix n’est mauvais. Celui qui convient à votre application dépend de ce que vous voulez que le modèle fasse une fois la tâche demandée terminée.
Invite 3 : Génération de code avec des contraintes spécifiques
Cette invite demande aux modèles d’implémenter une fonction petite mais non triviale : une fonction Python qui prend une liste d’événements horodatés et renvoie l’intervalle le plus long entre événements consécutifs, en gérant quatre cas limites. Les contraintes sont explicites ; l’intention est de tester la génération de code sous contraintes plutôt que le plafond de capacité — chaque modèle peut écrire cette fonction. Ce qui varie, c’est la façon de gérer les contraintes.
L’invite
Write a Python function that takes a list of timestamped events andreturns the longest gap (in seconds) between consecutive events. Requirements:- Function signature: longest_gap(events: list[datetime]) -> float- Handle these edge cases: 1. Empty list (return 0.0 or raise — your choice, but be consistent) 2. Single event 3. Duplicate timestamps 4. Unsorted input- Use only the standard library- Include type hints- Return just the function. No tests or usage examples.
À surveiller
Si le modèle traite bien les quatre cas limites ou en omet silencieusement certains. Si les annotations de type sont précises ou génériques. Si l’implémentation choisit un algorithme défendable (trier puis balayer) ou quelque chose d’exotique. Et si le modèle respecte la contrainte « pas de tests, pas d’exemples d’utilisation » à la fin de l’invite — c’est le type d’instruction tardive que les modèles au suivi d’instructions robuste respecteront, tandis que d’autres l’ignoreront discrètement.
Ce que les équipes rapportent systématiquement
GPT-5.5. Produit généralement le code le plus soigneusement conçu. Les quatre cas limites sont traités avec des branches explicites, les annotations de type sont précises (incluant souvent Optional ou Union pour les valeurs de retour liées aux cas limites), et un docstring avec des exemples d’appels. L’implémentation choisit généralement l’algorithme évident — trier, balayer, suivre l’écart max — et est correcte. À noter : GPT-5.5 inclut souvent des tests unitaires ou des exemples d’utilisation même lorsque l’invite demande explicitement uniquement la fonction. C’est le compromis avec les modèles pragmatiques opérationnels — ils ajoutent ce qu’ils pensent que vous allez vouloir, même si vous le leur demandez de ne pas le faire.
Claude Sonnet 4.6. Produit généralement le code le plus lisible. La fonction est concise, les cas limites sont gérés avec un schéma propre de clauses de garde au début, les annotations de type sont exactes et minimales. Claude inclut souvent un commentaire réfléchi expliquant un arbitrage que l’invite a laissé ouvert — par exemple, pour les horodatages dupliqués, les traiter comme des écarts de longueur zéro et expliquer pourquoi, ce qui est un choix défendable non spécifié par l’invite. Claude tend à respecter la contrainte « pas de tests » plus fidèlement que GPT-5.5. La fonction elle‑même est la plus facile à maintenir des trois. Cohérent avec la réputation de Claude pour la qualité du code : propre, idiomatique, d’allure experte.
Gemini 3.1 Pro. Produit généralement le code le plus économique des trois. La fonction est correcte, les cas limites gérés, l’implémentation est la plus courte. Le docstring est généralement d’une seule ligne. Les annotations de type sont présentes et exactes. La solution de Gemini inclut rarement des tests ou des commentaires étendus, et n’en fait pas trop — exactement ce que l’invite demandait. Pour un développeur qui veut une fonction opérationnelle et prévoit d’ajouter des tests séparément, c’est le chemin le plus direct. Pour un développeur qui souhaite que le modèle fasse aussi le travail périphérique, les deux autres en ajoutent davantage (que vous l’ayez demandé ou non).
Ce que cela vous apprend
Les trois modèles savent écrire la fonction. La différence comportementale réside dans la quantité de travail périphérique que chaque modèle ajoute au‑delà de la demande littérale — et dans la façon dont chacun respecte les instructions explicites « ne pas ajouter X ». GPT-5.5 penche vers la minutie, même lorsque l’invite y renonce. Claude penche vers l’artisanat (code lisible, commentaires réfléchis sur les arbitrages). Gemini penche vers l’économie (faire exactement ce qui est demandé, rien de plus). Pour des flux agentiques où la sortie du modèle part directement dans une base de code de production, le comportement souhaité dépend de ce qu’attend votre processus de revue en aval — et de la stricte nécessité que les instructions négatives soient respectées.
Les schémas qui émergent
À travers les trois invites ci‑dessus, trois schémas comportementaux cohérents émergent des études comparatives et retours développeurs publiés en 2026. Ce ne sont pas des affirmations de capacité — chaque modèle gère chaque tâche à un niveau élevé. Ce sont des tendances, le genre de choses que l’on ne voit que quand des équipes observent le même modèle sur des dizaines d’invites. Exécutez les invites ci‑dessus sur votre propre configuration et vous verrez les mêmes motifs ; l’article existe pour vous donner le cadre afin de reconnaître ce que vous regardez quand vous le faites.
| Modèle | Tendance comportementale | Idéal lorsque… |
|---|---|---|
| GPT-5.5 | Pragmatique opérationnel. Ajoute des indices d’exécution, du code défensif et des sorties favorables aux pipelines en aval. Fort sur les tâches modelées par l’agentique et l’usage d’outils. | Votre application enchaîne la sortie du modèle vers une exécution ultérieure — agents, workflows ou pipelines où l’étape suivante est automatisée. |
| Claude Sonnet 4.6 | Soin d’expert. Fait émerger des considérations au‑delà de la demande littérale, soulève des questions d’éthique et de méthodologie, produit un code très lisible. | Votre application inclut une relecture humaine de la sortie du modèle — génération de contenu, revue de code, analyses où le « craft » compte. |
| Gemini 3.1 Pro | Économique et direct. Fait exactement ce qui est demandé, rien de plus. Respect de schéma le plus propre et sortie token minimale à travail équivalent. | Votre application a des exigences de sortie strictes, la prévisibilité des coûts est prioritaire, ou vous voulez un modèle outil précis plutôt qu’un collaborateur réfléchi. |
Une mise en garde importante. Ces schémas sont des tendances, pas des règles. Chaque modèle peut être orienté vers l’un ou l’autre de ces comportements avec un prompt approprié — un prompt système suffisamment détaillé fera ajouter des tests à Gemini, contraindra Claude à une sortie minimale, ou amènera GPT-5.5 à sauter les tests unitaires. L’enjeu est ce que chaque modèle fait par défaut, avant que vous ne commenciez à le guider. Le comportement par défaut est ce avec quoi vous vivrez en production, à moins de le contrarier activement par le prompt.
Comment tester sur votre propre charge
L’exercice ci‑dessus est reproductible sur n’importe quelle charge, et il devrait l’être. Les scores de benchmark sont utiles comme premier filtre, mais les schémas de comportement qui comptent pour votre application spécifique ne sont visibles que lorsque vous observez les modèles traiter vos invites spécifiques.
Un guide pratique pour mener l’exercice sur votre propre trafic :
- Choisissez trois catégories d’invites représentatives. Pas trois invites aléatoires — trois catégories couvrant votre charge. La plupart des systèmes de production se décomposent en un petit nombre de types d’invites (extraction, classification, génération, raisonnement, code, synthèse). Choisissez les catégories qui représentent la majorité de votre trafic.
- Sélectionnez 20–30 exemples par catégorie. Idéalement issus du trafic réel. Anonymisez si nécessaire. L’objectif est que les invites ressemblent à ce que votre application voit réellement, pas à des questions de benchmark. Vingt exemples par catégorie suffisent à voir des motifs ; trente suffisent à être confiant.
- Faites‑les passer par un point de terminaison unique, tous les modèles. Un point de terminaison agrégateur compatible OpenAI rend cela bien plus rapide que d’exécuter chaque modèle via son propre SDK. Le code en haut de cet article constitue toute la configuration. La même température, les mêmes paramètres, la même invite — les différences de sortie sont les différences des modèles.
- Évaluez qualitativement avant quantitativement. Parcourez les sorties à l’œil d’abord. Les schémas comportementaux sont généralement évidents dans la première douzaine d’invites. Une fois que vous avez une hypothèse sur la façon dont chaque modèle se comporte sur votre charge, vous pouvez élaborer une grille pour noter — mais l’hypothèse vient de l’observation, pas d’un gabarit de notation pré‑construit.
- Faites attention à ce que le modèle ajoute. La question du benchmark est de savoir si le modèle donne la bonne réponse. La question comportementale est : que fait‑il d’autre ? Ajoute‑t‑il des tests ? Explique‑t‑il son raisonnement ? Soulève‑t‑il des préoccupations ? Produit‑il des champs supplémentaires non demandés ? C’est là que résident les différences entre modèles.
- Choisissez le modèle qui correspond à votre schéma en aval. Si votre processus en aval est automatisé, vous voulez un modèle dont le comportement par défaut produit des sorties propres et analysables. Si votre processus en aval est une revue humaine, vous voulez un modèle dont le comportement par défaut ajoute le type de jugement périphérique qu’un relecteur humain apprécierait. La bonne réponse dépend de ce qui vient après le modèle.
Conclusion
Le choix entre GPT-5.5, Claude Sonnet 4.6 et Gemini 3.1 Pro ne porte pas sur le « meilleur » modèle. Il porte sur le modèle qui correspond à la forme de votre charge — et cette forme est quelque chose que les benchmarks ne voient pas. L’exercice ci‑dessus est réalisable en une après‑midi si vous avez les invites sélectionnées ; l’intérêt de le faire est que vous cessez de deviner et commencez à observer.
Les benchmarks vous disent ce qu’un modèle peut faire. Les schémas de comportement vous disent ce qu’un modèle fera, par défaut, sur vos invites. La première réponse est publiée. La seconde, vous devez l’observer vous‑même. Vingt invites par catégorie, une après‑midi, et vous avez une réponse qu’aucun classement ne produira jamais.
Prêt à intégrer de manière fiable ? Rendez‑vous sur CometAPI et la Documentation de l’API pour un accès fluide à Claude Fable 5 aux côtés d’autres modèles de pointe, avec facturation unifiée et fiabilité de niveau entreprise. Inscrivez‑vous aujourd’hui et commencez avec des crédits généreux pour les nouveaux utilisateurs — votre prochain projet révolutionnaire vous attend.