Guide de prompting GPT-5.6 : deux valeurs par défaut qui facturent 1,5x et 10x plus cher

Bien prompter GPT-5.6 tient essentiellement à deux paramètres de requête, et les deux ont une valeur par défaut coûteuse. Omettre reasoning_effort a facturé 1,5x plus cher que de le fixer à "none" sur notre matrice de 50 appels, pour des réponses identiques ; laisser un préfixe stable non marqué le facture à 10x le tarif des lectures en cache à chaque appel. Ce guide est le playbook de mise en forme des requêtes qui découle des mesures de notre guide des coûts GPT-5.6 : à quoi ressemble une requête bien formée, comment régler le curseur d’effort selon la tâche, comment structurer un prompt pour que le cache fasse son travail, et ce qui casse quand on porte des prompts depuis GPT-5.5.

TL;DR

• Fixez reasoning_effort sur chaque requête GPT-5.6 : l’omettre a facturé 1,5x plus cher que "none" pour des réponses identiques sur notre matrice de 4 tâches.
• Les efforts acceptés vont de none à xhigh ; "max" renvoie une 400 sur Sol comme sur Terra.
• Marquez les préfixes stables avec des breakpoints de cache explicites : les lectures en cache sont facturées à 10 % du tarif d’entrée, les écritures à 1,25x. Marquez donc ce qui se répète, pas ce qui a simplement l’air stable.
• prompt_cache_options et les breakpoints renvoient une 400 sur GPT-5.5 et versions antérieures ; conditionnez le déploiement à la version.

À quoi doit ressembler une requête GPT-5.6 ?

Partez de cette structure et supprimez ce dont vous n’avez pas besoin. Elle fixe les deux leviers explicitement au lieu d’hériter des valeurs par défaut coûteuses :

{
  "model": "gpt-5.6-terra",
  "reasoning_effort": "low",
  "prompt_cache_options": { "mode": "explicit", "ttl": "30m" },
  "prompt_cache_key": "tenant-42",
  "messages": [
    { "role": "system", "content": "…stable instructions…",
      "prompt_cache_breakpoint": { "mode": "explicit" } },
    { "role": "user", "content": "…the part that changes per request…" }
  ]
}

La règle d’ordonnancement derrière tout ça : tout ce qui est stable passe avant le breakpoint, tout ce qui change à chaque requête passe après, et rien de dynamique (horodatages, noms d’utilisateur, documents récupérés qui diffèrent d’un appel à l’autre) ne se trouve à l’intérieur du bloc marqué. Un seul octet modifié refacture le bloc au tarif d’écriture majoré de 1,25x. La prompt_cache_key route les répétitions vers le même cache ; utilisez une clé stable par tenant ou par session, et gardez en tête la limite souple documentée d’environ 15 requêtes par minute et par clé.

Quelle valeur donner à reasoning_effort ?

Toujours de façon explicite : la seule erreur, c’est de ne rien préciser. Dans nos mesures, les requêtes sans reasoning_effort coûtaient 1,5x plus cher que celles fixées à "none", pour des réponses identiques sur toute la matrice. Les valeurs acceptées sont none, low, medium, high, xhigh ; "max" renvoie un 400 qui liste la plage valide. Voici ce que ce réglage a changé sur notre test de maths d’une ligne, avec Luna :

GPT-5.6 était la seule famille de notre étude sur l’anatomie de l’usage des tokens à rester correcte avec le raisonnement totalement désactivé sur ce test, ce qui fait de none un défaut défendable pour l’extraction, la classification, le formatage et les appels de type retrieval. Quand le modèle raisonne, les tokens sont invisibles et facturés au tarif de sortie plein : 88 % du coût de sortie de l’exemple de maths avec le réglage par défaut correspondait à une chaîne de raisonnement que vous ne pouvez pas lire. Montez le curseur quand vos évals disent que la tâche en a besoin, pas parce que le défaut l’a déjà payé.

Comment structurer un prompt pour que le cache rapporte ?

Organisez le prompt par ordre de stabilité et marquez les couches : instructions système d’abord, puis définitions d’outils, puis documents de référence, chacune se terminant par un breakpoint, avec le tour utilisateur volatile après le dernier marqueur. Vous avez droit à quatre écritures de cache par requête ; en mode implicite par défaut, un breakpoint automatique sur le dernier message en consomme une, donc le mode explicite vous donne les quatre complètes et, surtout, ne met en cache que ce que vous marquez.

La réutilisation partielle est le gain, et il est mesuré. Avec un bloc stable A et une fin B remplacée, le compteur n’a refacturé que la fin : 1 212 tokens relus au tarif cache, 1 210 écrits à neuf au tarif premium, sur un prompt de 2 431 tokens, qui se rapproche du barème au chiffre près. Trois règles de budget en découlent :

• Les lectures sont facturées à 10 % du tarif d’entrée, donc un préfixe en couches déjà chaud aplatit le côté entrée de la facture.
• Les écritures sont facturées à 1,25x, donc un bloc marqué qui n’est plus jamais relu coûte 25 % de plus que sans cache. Marquez ce qui se répète, pas tout ce qui a l’air stable.
• Sur les répétitions complètes, la longueur correspondante peut passer sous le marqueur (1 897 en cache sur une écriture de 2 422 tokens dans un test), donc budgétez sur le tarif réduit, pas sur des comptages de correspondance exacte ; notre étude sur les minimums de cache donne les seuils par famille.

Le plancher ttl: "30m" est un minimum garanti, pas un plafond, et il vaut 6x le défaut de 5 minutes de Claude ; il n’existe plus de palier à 24 heures, donc les workloads de batch quotidien qui misaient sur une rétention étendue devraient recalculer leur point d’équilibre.

Qu’est-ce qui casse quand on porte des prompts depuis GPT-5.5 ?

Deux choses cassent bruyamment et une silencieusement. Bruyamment : prompt_cache_options et prompt_cache_breakpoint renvoient un 400 net sur GPT-5.5 et plus ancien (prompt_cache_options is not supported on this model), donc tout constructeur de prompt partagé a besoin d’un aiguillage par version. Bruyamment aussi : l’effort "max", que certaines configs 5.5 embarquaient, est rejeté.

Silencieusement, et plus coûteusement : GPT-5.6 raisonne par défaut là où un workload 5.5 pouvait avoir le raisonnement désactivé. Un prompt porté qui ne fixe jamais reasoning_effort récupère la taxe d’omission de 1,5x au même barème. La migration du cache va dans l’autre sens : la détection automatique de préfixe de 5.5 ne demandait aucun balisage mais ne pouvait être ni déclenchée ni déboguée ; sur 5.6 le même prompt ne fait rien tant que vous ne le marquez pas, puis reporte chaque écriture dans usage.prompt_tokens_details.cache_write_tokens, où un raté apparaît comme un zéro dans un champ que vous avez créé plutôt que comme un silence.

Sur quel tier faire tourner le prompt ?

La forme de requête est identique sur les trois tiers : le choix du tier est donc une question de prix, pas de prompting. Sol est à 5/30 $ par million de tokens, Terra à la moitié, Luna à un cinquième. Une fois le préfixe stable, associé à une clé et chaud, la remise sur les lectures en cache aplatit le coût côté input sur tous les tiers, et c’est donc le prix de l’output qui fait la différence ; descendez aussi bas que le permettent vos évals sur la qualité de sortie. Le calcul complet par tier, y compris le seuil de rentabilité de la prime d’écriture par tier, est détaillé dans le guide des coûts.

FAQ

GPT-5.6 supporte-t-il reasoning_effort: “max” ?

Non. Une requête avec "max" renvoie une 400 qui liste none jusqu’à xhigh comme valeurs valides, aussi bien sur Sol que sur Terra. Pour pousser au maximum, envoyez explicitement xhigh.

Les breakpoints de cache fonctionnent-ils sur GPT-5.5 ?

Non. GPT-5.5 et les versions antérieures rejettent prompt_cache_options et les marqueurs de breakpoint avec une 400. Sur ces modèles, on retombe sur la détection automatique de préfixe, qu’on ne peut ni déclencher, ni associer à une clé, ni débugger ; considérez le comportement du cache comme du best-effort et gardez derrière un version-gate tout constructeur de prompt qui émet les nouveaux champs.

Combien de breakpoints un prompt doit-il vraiment utiliser ?

Autant de couches qui se répètent réellement, dans la limite du budget : quatre écritures par requête, dont une consommée par l’auto-breakpoint implicite tant que vous ne passez pas en mode explicite. Un prompt en couches typique en demande deux ou trois (instructions, tools, bloc de référence). Un cinquième marqueur est accepté sans erreur, mais partage simplement les slots d’écriture, puisqu’une marque plus tardive couvre tout ce qui la précède.

Tous les chiffres de ce guide ont été mesurés via le gateway Synthorai sur les modèles GPT-5.6 du jour de sortie et se recoupent avec le compteur usage.cost en direct ; la méthodologie et les sondes brutes sont dans le guide des coûts et dans l’étude sur les minimums de prompt cache. Vérifiez avec vos propres relevés d’usage ; les tarifs et les valeurs acceptées peuvent changer.

← Retour au blog