GPT-5.5 vs Claude Sonnet 4.6 vs Gemini 3.1 Pro : ce qu'aucun benchmark ne vous dit

Il existe un type particulier de réunion qui se tient dans toute équipe bâtissant sur des LLM de pointe. Quelqu’un partage le dernier classement des benchmarks. Quelqu’un d’autre fait remarquer que le classement a changé depuis le mois dernier. Une troisième personne note que le modèle que son équipe utilise 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 suivant.

Le problème de cette réunion n’est pas les 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 indique la performance d’un modèle sur MMLU, sur SWE-bench Verified, sur GPQA Diamond — des tests conçus par des chercheurs pour être mesurables entre modèles. Aucun de ces tests ne ressemble aux invites que votre application envoie réellement en production. Aucun ne capture la façon dont un modèle gère le type d’entrée spécifique, désordonnée et modelée par votre domaine, que vos utilisateurs génèrent.

Cet article parcourt précisément 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 endpoint compatible avec OpenAI, avec les mêmes paramètres de température et sans supplément de prompting. 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 fortement axée sur le raisonnement, et la génération de code sous contraintes. Les observations ci-dessous sont les schémas comportementaux que les équipes réalisant ce type de comparaison rapportent systématiquement — les schémas que vous verriez vous-même si vous exécutiez ces invites dans 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 tient pas à celui qui obtient la meilleure note sur les benchmarks — il s’agit de savoir quel schéma de comportement convient à votre charge.

Ce que mesurent les benchmarks, et ce qu’ils manquent

Les benchmarks existent parce qu’ils le doivent. Les fournisseurs de modèles ont besoin de tests standardisés pour étayer leurs revendications de capacités, les chercheurs en ont besoin pour publier des comparaisons, et le reste d’entre nous en a besoin pour disposer de tout point de départ objectif pour évaluer les modèles. Ils sont utiles. Ils sont aussi incomplets d’une manière qui compte en production.

Trois limites spécifiques méritent d’être explicitement mentionnées, car chacune se manifeste dans les exemples d’invite ci-dessous.

• Les benchmarks mesurent des capacités isolées, pas des schémas de comportement. SWE-bench Verified vous indique 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‑ingénier des problèmes simples, s’il pose des questions de clarification quand l’invite est ambiguë, ou s’il produit dès le premier coup une sortie qui respecte la structure demandée. Ce sont les choses que vous observerez au quotidien en production.
• Les benchmarks sont optimisés pour. Lorsqu’une version de modèle met fortement en avant son score sur un benchmark particulier, c’est le signal que le modèle a été au moins partiellement optimisé pour ce benchmark. Les performances réelles et celles au benchmark peuvent diverger — parfois fortement — une fois que le modèle sort des conditions pour lesquelles le benchmark a été conçu.
• Les benchmarks agrègent. Une différence 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âche spécifique et moins bon sur une autre, tandis que le Modèle B est régulier sur l’ensemble. L’agrégation écrase l’information 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. L’objectif n’est pas de désigner un gagnant — il est de montrer les questions que vous devriez vous poser lorsque vous exécutez le même exercice sur vos propres invites.

La configuration

Trois invites, choisies parce qu’elles correspondent à des catégories auxquelles la plupart des charges de production se heurtent. La configuration : chaque invite est envoyée aux trois modèles avec des paramètres identiques (température 0.3, pas de remplacement de système prompt, format de réponse par défaut), via un seul endpoint compatible avec OpenAI afin que la comparaison reste homogène — pas d’astuces spécifiques à un SDK fournisseur, pas de mappages de paramètres différents, pas de risque qu’un modèle bénéficie d’un traitement particulier à cause de la construction de la requête.

Les invites elles‑mêmes sont 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 lorsqu’elles réalisent ce type de comparaison — des schémas documentés dans de multiples études tierces en 2026, et le genre de choses que vous devriez vous attendre à voir vous‑même lorsque vous exécutez ces invites dans votre propre environnement. L’objectif est de le faire vous‑même ; l’article vous donne le cadre et les invites de départ pour cela.

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 à partir d’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 extraire des champs spécifiques dans un objet structuré. L’invite ci‑dessous demande à chaque modèle d’extraire sept champs depuis un e‑mail de support client volontairement brouillon contenant des informations partielles, des signaux contradictoires, et un champ qui n’est pas présent dans le texte 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 points. D’abord, si le modèle respecte le schéma JSON demandé sans invention. Ensuite, la façon dont le modèle gère le champ qui n’existe pas dans la source (escalation_history — le client ne mentionne aucun contact préalable au sujet de ce problème) — admet‑il l’absence, ou fabrique‑t‑il de façon plausible ? Enfin, si le modèle produit un commentaire additionnel en dehors du JSON, nécessitant un post‑traitement en aval pour supprimer cet emballage. Le champ d’urgence mérite aussi attention : « 5 days » n’est pas immédiat mais le client est clairement anxieux, ce qui laisse place à l’interprétation.

Ce que rapportent systématiquement les équipes qui exécutent cet exercice

GPT-5.5. Produit généralement du JSON propre du premier coup. 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 balises de code Markdown et n’inclut pas d’explication en prose, ce qui rend le parsing en aval trivial. Sur des choix interprétatifs ambigus comme la cotation de l’urgence ici, GPT-5.5 est souvent plus conservateur que les deux autres — là où Claude et Gemini peuvent évaluer le ticket en « high » sur la base du ton émotionnel du client, GPT-5.5 s’ancre souvent sur la fenêtre concrète de 5 jours et aboutit à « medium ».

Claude Sonnet 4.6. Produit également du JSON propre, et est généralement le plus précis des trois dans le suivi 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 » qui n’était pas demandée mais contient des informations réellement utiles. Ce champ supplémentaire est utile pour les 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 haute qualité, mais parfois plus exhaustif que ce que l’invite demandait, nécessitant des consignes explicites pour le 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 environnante. Le respect du schéma est exactement conforme à la demande. Une particularité à connaître : pour les champs manquants, Gemini renvoie souvent une chaîne vide plutôt que null. Les parseurs JSON stricts qui distinguent les deux détecteront la différence ; les parseurs plus souples non. Le comportement est suffisamment constant d’un run à l’autre pour sembler une préférence du modèle plutôt qu’un artefact.

Ce que cela vous apprend

Les trois modèles savent faire de l’extraction structurée. Les différences résident dans les marges comportementales 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 des problèmes de qualité des données sans y être invité, Claude Sonnet 4.6 est plus utile. Rien de cela n’apparaît sur un benchmark.

Invite 2 : Une tâche de planification exigeant du raisonnement

Cette invite demande aux modèles de planifier une investigation 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 toute invocation d’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 rapport 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 points avant de dérouler les étapes.

À surveiller

Si le modèle raisonne réellement sur le problème ou s’il produit une suite d’étapes plausible en apparence mais qui ne tient pas à l’examen. S’il identifie les contraintes implicites sans y être invité. Et si les dépendances entre étapes sont correctes — un plan qui a l’air convenable mais où l’étape trois dépend d’un résultat que l’étape cinq produit ne sert à rien en pratique.

Ce que rapportent systématiquement les équipes qui exécutent cet exercice

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 facilite la mise en évidence des divergences d’interprétation. Les dépendances entre étapes sont identifiées et étiquetées de manière fiable. La sortie inclut souvent une section indiquant quelles étapes peuvent être parallélisées, ce qui n’était pas demandé mais apporte une véritable valeur. C’est le genre de tâche où l’entraînement à l’usage d’outils et à l’agentisation de GPT-5.5 apparaît — le comportement de planification est façonné par l’hypothèse qu’une exécution en aval suivra.

Claude Sonnet 4.6. Produit généralement le plan le plus réfléchi, au sens littéral — 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 » peut lui‑même être un symptôme du churn plutôt qu’une cause, et d’identifier explicitement des contraintes qui n’étaient pas explicites mais qu’un analyste soigneux devrait repérer. Le revers : le plan peut être plus long que nécessaire, et certaines étapes sont parfois sur‑ingénierées au regard de la question. Le motif est cohérent avec le comportement de Claude ailleurs — une attention d’expert, parfois plus que ce que la tâche requiert.

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 manière fiable les contraintes implicites, décompose le problème en une séquence défendable, et produit des instructions pas à pas réellement exécutables. L’inconvénient : le plan peut paraître quelque peu mécanique. Il fait le travail mais a tendance à ne pas faire ressortir les subtilités méthodologiques que Claude met en avant, ni les idées de parallélisation que GPT-5.5 inclut. Cela correspond au motif plus large de Gemini — fort en raisonnement, plus « besogneux » 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 requête littérale. GPT-5.5 ajoute du pragmatisme opérationnel (parallélisation, indices 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 accomplie.

Invite 3 : Génération de code avec 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’écart 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és — chaque modèle peut écrire cette fonction. Ce qui varie, c’est leur manière 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 parcourir) ou quelque chose d’exotique. Et si le modèle respecte la contrainte « pas de tests, pas d’exemples d’usage » à la fin de l’invite — c’est le type d’instruction tardive que les modèles ayant une forte faculté de suivi des consignes respecteront, tandis que d’autres la violeront discrètement.

Ce que rapportent systématiquement les équipes qui exécutent cet exercice

GPT-5.5. Produit généralement le code le plus solidement « ingénieré ». Les quatre cas limites sont traités avec des branches explicites, les annotations de type sont précises (souvent avec Optional ou Union pour les valeurs de retour dans les cas limites), et un docstring avec des exemples d’appels. L’implémentation choisit généralement l’algorithme évident — trier, parcourir, suivre l’écart max — et est correcte. À savoir : GPT-5.5 inclut souvent des tests unitaires ou des exemples d’utilisation même lorsque l’invite demande explicitement de ne fournir que la fonction. C’est le compromis avec les modèles pragmatiques opérationnels — ils ajoutent ce qu’ils pensent dont vous aurez besoin, même si vous n’avez pas demandé.

Claude Sonnet 4.6. Produit généralement le code le plus lisible. La fonction est concise, les cas limites gérés avec un schéma de garde clair en tête, les annotations de type exactes et minimales. Claude inclut souvent un commentaire réfléchi expliquant un choix laissé ouvert par l’invite — par exemple, sur les horodatages dupliqués, les traiter comme des écarts de longueur nulle et expliquer pourquoi, un choix défendable que l’invite n’avait pas spécifié. Claude tend à respecter plus fidèlement que GPT-5.5 la contrainte « pas de tests ». La fonction elle‑même est la plus maintenable des trois. Conforme à la réputation de Claude pour la qualité du code : propre, idiomatique, avec une touche d’expert.

Gemini 3.1 Pro. Produit généralement le code le plus économique des trois. La fonction est correcte, les cas limites traités, l’implémentation la plus courte. Docstring généralement sur une seule ligne. Annotations de type présentes et exactes. La solution de Gemini inclut rarement des tests ou des commentaires étendus, et n’« over‑engineer » pas — exactement ce que demandait l’invite. Pour un développeur qui veut une fonction qui marche et compte ajouter des tests séparément, c’est le chemin le plus direct. Pour un développeur qui veut que le modèle fasse aussi le travail périphérique, les deux autres en ajoutent davantage (que vous le demandiez ou non).

Ce que cela vous apprend

Les trois modèles savent écrire la fonction. La différence comportementale tient à la quantité de travail périphérique que chaque modèle fait au‑delà de la requête littérale — et à la rigueur avec laquelle chacun respecte les instructions négatives explicites. GPT-5.5 penche vers l’exhaustivité, même lorsque l’invite l’écarte. Claude penche vers l’artisanat (code lisible, commentaires réfléchis sur les choix). Gemini penche vers l’économie (faire exactement ce qui est demandé, pas plus). Pour les workflows agentiques où la sortie du modèle va directement dans une base de code de production, le comportement souhaité dépend de ce que votre processus de revue en aval attend — et du degré de stricte observance dont vous avez besoin pour les instructions négatives.

Les schémas qui émergent

Sur les trois invites ci‑dessus, trois schémas comportementaux constants émergent des études comparatives et retours de développeurs publiés tout au long de 2026. Il ne s’agit pas d’allégations de capacité — chaque modèle traite chaque tâche à un haut niveau. Ce sont des tendances, du type de celles que l’on ne voit que lorsque des équipes observent le même modèle sur des dizaines d’invites. Exécutez les invites ci‑dessus dans votre propre configuration et vous verrez les mêmes schémas ; l’article existe pour vous donner le cadre de reconnaissance de ce que vous regardez lorsque vous le faites.

Une mise en garde importante. Ces schémas sont des tendances, pas des règles. Chaque modèle peut être piloté vers n’importe lequel de ces comportements avec un prompting approprié — un système prompt suffisamment détaillé fera ajouter des tests par Gemini, ou contraindra Claude à une sortie minimale, ou amènera GPT-5.5 à omettre les tests unitaires. L’enjeu est ce que chaque modèle fait par défaut, avant que vous ne commenciez à le diriger. Le comportement par défaut est ce avec quoi vous vivrez en production à moins de le contrer activement par le prompt.

Comment tester sur votre propre charge

L’exercice ci‑dessus est reproductible sur toute charge, et il devrait l’être. Les scores de benchmark sont utiles comme premier filtre, mais les schémas de comportement du modèle qui comptent pour votre application spécifique ne sont visibles que lorsque vous regardez les modèles traiter vos invites spécifiques.

Un guide pratique pour exécuter l’exercice sur votre propre trafic :

1. Choisissez trois catégories d’invite représentatives. Pas trois invites au hasard — trois catégories qui couvrent votre charge. La plupart des systèmes de production peuvent se décomposer en quelques types d’invite (extraction, classification, génération, raisonnement, code, synthèse). Choisissez les catégories qui représentent l’essentiel de votre trafic.
2. Sélectionnez 20–30 exemples par catégorie. Idéalement issus du trafic réel. Anonymisez si nécessaire. L’idée est que les invites ressemblent à ce que votre application voit réellement, pas à des questions de benchmark. Vingt exemples par catégorie suffisent pour voir des schémas ; trente suffisent pour être confiants.
3. Exécutez‑les via un seul endpoint, sur tous les modèles. Un endpoint agrégateur compatible avec OpenAI rend cela bien plus rapide que de passer chaque modèle par son propre SDK. Le code en tête de cet article est l’intégralité de la mise en place. La même température, les mêmes paramètres, la même invite — les différences de sortie sont les différences de modèle.
4. Évaluez qualitativement avant quantitativement. Parcourez les sorties à l’œil d’abord. Les schémas comportementaux sont généralement évidents sur 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 construire une grille pour noter — mais l’hypothèse vient de l’observation, pas d’un gabarit de notation pré‑construit.
5. Faites attention à ce que le modèle ajoute. La question du benchmark est de savoir si le modèle trouve la bonne réponse. La question comportementale est de savoir ce que le modèle fait en plus. Ajoute‑t‑il des tests ? Explique‑t‑il son raisonnement ? Soulève‑t‑il des préoccupations ? Produit‑il des champs supplémentaires que vous n’avez pas demandés ? C’est là que résident les différences entre modèles.
6. 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éciera. 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 concerne pas le modèle « le meilleur ». Il s’agit de celui qui épouse 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 préparé les invites ; la valeur vient du fait que vous cessez de deviner et commencez à observer.

Pour les équipes qui exécutent l’exercice elles‑mêmes : la mise en place la plus simple est un endpoint unique compatible avec OpenAI qui expose les trois modèles derrière un seul identifiant. CometAPI est une voie ; vous pointez votre SDK OpenAI existant vers une autre base URL et le paramètre du modèle devient la variable.

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 façon 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, une facturation unifiée et une fiabilité de niveau entreprise. Inscrivez‑vous dès aujourd’hui et démarrez avec des crédits généreux pour les nouveaux utilisateurs — votre prochain projet décisif vous attend.