GPT-6.2 Astra et Sol ne sont pas deux tailles du même achat. Astra est le modèle d'OpenAI pour les projets les plus difficiles ; Sol est son modèle pour le travail quotidien et les agents à fort volume. Aux tarifs catalogue standard pour contexte court, Astra coûte quatre fois plus par token d'entrée et de sortie. La question pratique n'est donc pas quel modèle sonne le plus fort, mais lequel franchit votre seuil d'acceptation au coût par tâche réellement utilisable le plus bas — et quand une meilleure sortie mérite de payer une prime.
Périmètre et preuves. OpenAI a publié le lancement de GPT-6.2 Astra et Sol le 17 novembre 2026. Les spécifications et prix catalogue ci-dessous proviennent de l'annonce de lancement d'OpenAI et des pages de modèle officielles, vérifiés le 18 novembre 2026. Il s'agit d'un guide de planification, non d'un rapport de benchmark : nous n'avons exécuté aucun modèle, mesuré aucune latence ni noté aucune sortie. L'exemple de coût est de l'arithmétique à partir des tarifs officiels plus les hypothèses indiquées. Le catalogue international ToAPIs liste Astra et Sol ; utilisez le catalogue en direct pour les variantes, tarifs et routages disponibles sur votre compte. Cet article n'affirme pas de tarifs, chemins d'endpoint ou couverture régionale spécifiques à la plateforme.
1. Les faits officiels qui ancrent la décision
L'annonce de lancement d'OpenAI positionne Astra pour le travail professionnel complexe — présentations, tableurs, documents, programmation, usage de l'ordinateur et raisonnement visuel — et Sol pour les tâches techniques et non techniques du quotidien, y compris les workflows agentiques à plusieurs étapes. Les deux acceptent le texte et les images et renvoient du texte. Les pages de modèle officielles listent les mêmes limites de contexte et de sortie pour chacun :
| Spécification | GPT-6.2 Astra | GPT-6.2 Sol |
|---|---|---|
| ID de modèle API | gpt-6.2-astra | gpt-6.2-sol |
| Positionnement OpenAI | Les projets les plus difficiles, de bout en bout | Travail quotidien et agents à l'échelle |
| Modalités d'entrée | Texte, image | Texte, image |
| Sortie | Texte | Texte |
| Fenêtre de contexte | 1 050 000 tokens | 1 050 000 tokens |
| Entrée maximale | 922 000 tokens | 922 000 tokens |
| Sortie maximale | 128 000 tokens | 128 000 tokens |
| Date de coupure des connaissances | 18 mai 2026 | 1er juin 2026 |
| Réglage du raisonnement | Maximum ; none est rejeté | Maximum ; none est rejeté |
| Fine-tuning | Non pris en charge | Non pris en charge |
La différence économique principale est le prix, pas une limite de contexte différente :
| Tarif catalogue standard pour contexte court | Astra | Sol | Astra / Sol |
|---|---|---|---|
| Entrée, par million de tokens | $8.00 | $2.00 | 4x |
| Entrée en cache, par million de tokens | $0.40 | $0.10 | 4x |
| Sortie, par million de tokens | $40.00 | $10.00 | 4x |
| Écriture de cache de 30 minutes, par million de tokens | $10.00 | $2.50 | 4x |
Source : page de tarifs de l'API OpenAI et pages de modèle, vérifiées le 18 novembre 2026. Les tarifs sont en USD par million de tokens, avant taxes et frais de plateforme éventuels. Ce sont des prix catalogue de référence, pas un devis ToAPIs.
OpenAI formule aussi des affirmations de performance rapportées par l'éditeur. Il indique que Sol se situe à 0,5 point d'Astra sur FrontierCode 2.0 de Cognition pour environ un cinquième du coût (les deux au raisonnement maximal), et rapporte Astra à 1 318 Elo contre 1 259 pour Sol sur l'évaluation de préférence humaine AA-3D d'Artificial Analysis. Ce sont des résultats rapportés par l'éditeur dans des configurations que nous n'avons pas auditées. Traitez-les comme des hypothèses ; vos prompts, outils et règles d'acceptation peuvent produire un ordre différent.
2. L'écart de prix de 4x : ce qui doit être vrai pour Astra
Aux tarifs catalogue standard pour contexte court, Astra et Sol ont la même relation 4:1 pour l'entrée, la sortie et l'entrée en cache. Si les deux modèles consomment le même nombre de tokens facturables et nécessitent le même nombre de tentatives, Astra ne peut pas avoir un coût par tâche acceptée plus faible sauf si son taux d'acceptation est plus de quatre fois celui de Sol. Comme l'acceptation plafonne à 100 %, cela devient impossible dès que le taux d'acceptation de Sol dépasse 25 %.
Cette affirmation a une portée étroite : même volume de tokens, mêmes tentatives, mêmes unités facturables. Elle reste un point de départ utile, car elle montre à quel point l'écart de qualité doit être important avant qu'Astra ne l'emporte sur le seul coût. La sensibilité du point d'équilibre est la suivante :
| Taux d'acceptation de Sol | Acceptation d'Astra nécessaire pour égaler le coût par tâche acceptée de Sol |
|---|---|
| 10 % | 40 % |
| 15 % | 60 % |
| 20 % | 80 % |
| 25 % | 100 % |
| 30 % | 120 % (inatteignable) |
| 50 % | 200 % (inatteignable) |
Suppose des nombres de tokens et de tentatives identiques par tâche, et que chaque tentative est facturée. Un profil de tokens différent déplace le point d'équilibre.
Le cadrage du point d'équilibre n'est pas un argument que Astra est surévalué. C'est un argument contre le fait de traiter l'étiquette « meilleur modèle » comme une politique de routage. Astra peut être rationnel quand la sortie de Sol est inutilisable, qu'une mauvaise réponse coûte cher, ou que la réparation humaine coûte plus que la prime de tokens. Il est rarement la valeur par défaut pour la classification, l'extraction ou les réponses de support courtes et routinières.
Trois nuances comptent :
- L'efficacité des tokens peut déplacer le ratio. Si Astra atteint l'acceptation avec nettement moins de tokens de sortie ou de tentatives, sa prime effective est inférieure à 4x. Nous n'avons pas de mesures appariées, donc nous n'affirmons aucun chiffre.
- Le ratio n'est pas la facture. Au-delà de 272 000 tokens d'entrée, les tarifs d'entrée et de cache doublent et la sortie coûte 1,5x pour toute la requête. La relation 4:1 des tarifs catalogue demeure, mais les coûts absolus augmentent ; ne réutilisez pas d'exemples de contexte court pour du travail en contexte long.
- D'autres unités facturables peuvent casser le ratio. Les appels d'outils, conteneurs, recherche de fichiers, modes batch ou Fast, Ultrafast, fenêtres d'arrière-plan, majorations régionales, taxes et frais de plateforme sortent de cette arithmétique. Consultez la page de tarifs officielle et le tarif de votre compte.
3. Carte des scénarios : où chaque modèle gagne sa place
La décision devient plus claire quand vous nommez la charge de travail, le coût de l'échec et le volume. Le tableau ci-dessous est une politique de départ, pas une affirmation sur une qualité mesurée.
| Charge de travail | Commencer par | Passer à Astra quand | Principal moteur de coût |
|---|---|---|---|
| Support, classification et extraction à fort volume | Sol | Les cas ambigus ou à forte valeur échouent à la grille, ou une mauvaise réponse déclenche une revue manuelle coûteuse | Tentatives par tâche et taux d'acceptation |
| Tâches de code ciblées, génération de tests, revue de PR | Sol | Le changement touche plusieurs fichiers, exige un jugement de conception, ou une régression est coûteuse à détecter plus tard | Coût par tâche acceptée plus temps de revue |
| Présentations, tableurs, notes, livrables clients | Sol pour les brouillons | La fidélité au modèle, la synthèse factuelle et l'utilisabilité au premier passage déterminent si le livrable est utilisable | Reprise et temps de revue |
| Agents à long horizon et workflows avec outils | Sol pour l'exécution | La planification ou les étapes ambiguës échouent de façon répétée, ou l'agent a besoin d'un jugement visuel ou d'usage de l'ordinateur plus fort | Tokens cumulés et nouvelles tentatives |
| Frontends visuels, 3D, CAO et interactifs | Sol pour les pages simples | La précision spatiale, la qualité visuelle ou un usage détaillé de l'ordinateur déterminent le résultat pour l'utilisateur | Nouvelles tentatives et revue humaine |
| Traitement batch hors ligne | Sol | Un filtre de qualité rejette trop de sorties de Sol, ou la tâche est intrinsèquement de niveau frontière | Remises batch et taux de rejet |
Support et extraction à fort volume : Sol est l'option économique par défaut
Un pipeline de triage de support ou d'extraction de factures peut traiter des milliers de requêtes courtes par jour, avec quelques milliers de tokens d'entrée et une étiquette courte ou une sortie JSON. Le tarif $2/$10 de Sol est un avantage majeur, et son contexte de 1,05 M égale celui d'Astra : la capacité de contexte n'est donc pas une raison de monter en gamme. Escaladez uniquement des échecs précis : un échec de schéma sur un compte à forte valeur, des documents sources contradictoires, ou une erreur qui déclenche une revue de remboursement ou de conformité. Mesurez cette cohorte ; ne déplacez pas toute la file parce qu'une démo semblait meilleure.
Changements de code sur tout le dépôt : la qualité se voit dans le temps de revue
Pour un correctif d'une ligne, Sol est la première tentative sensée. Pour une refonte multi-fichiers au design flou, le coût réel inclut la lecture par des ingénieurs seniors, la recherche des sites d'appel oubliés et la réparation des tests. Si Sol a besoin de plusieurs tours alors qu'Astra produit un changement mergeable en un ou deux, Astra peut être moins cher par changement accepté malgré le prix de tokens 4x. L'acceptation doit être une exécution : appliquez le patch et lancez les tests dans un environnement jetable ; un diff plausible ne suffit pas.
Livrables professionnels : la prime d'Astra est plus facile à justifier
Les présentations, classeurs de valorisation, synthèses juridiques et notes clients ont des coûts de reprise élevés. Un deck qui ignore le modèle ou une note qui omet une clause obligatoire peut consommer plus de temps humain que les frais du modèle. OpenAI positionne Astra pour les conventions professionnelles et la fidélité aux modèles. Faites tout de même une revue à l'aveugle avec le vrai modèle : si le brouillon de Sol est utilisable, payez Sol ; s'il doit être restructuré, comparez le temps de revue avec la prime d'Astra.
Agents et workflows visuels : séparez le planificateur de l'exécutant
Les workflows agentiques accumulent du contexte, donc l'écart de prix se compose. Un schéma courant est Sol pour les appels d'outils routiniers, l'extraction et les réponses courtes, avec Astra réservé à la planification, aux décisions ambiguës ou aux étapes visuelles ou d'usage de l'ordinateur qui déterminent la trajectoire. Fixez des budgets de tokens et de tentatives par tâche. Enregistrez la trace complète et évaluez la tâche terminée, pas le meilleur message intermédiaire.
4. Un exemple de coût simple
Prenez une tâche qui utilise 10 000 tokens d'entrée et 2 000 de sortie par appel, aux tarifs catalogue standard pour contexte court d'OpenAI. Chaque appel est une tentative, et chaque appel est facturé :
- Sol : $0.02 d'entrée plus $0.02 de sortie = $0.04 par appel.
- Astra : $0.08 d'entrée plus $0.08 de sortie = $0.16 par appel.
Si Sol réussit à sa deuxième tentative, la tâche coûte $0.08. Si Astra réussit à sa première tentative, elle coûte $0.16. Si Sol a besoin de cinq tentatives, elle coûte $0.20 — plus que l'unique appel réussi d'Astra. La prime ne vaut donc la peine que lorsqu'Astra évite assez de nouvelles tentatives ou d'édition pour combler cet écart. Les nombres de tentatives sont des hypothèses d'illustration, pas des mesures ; utilisez vos propres journaux.
C'est la version pratique du coût par tâche acceptée : compter chaque appel facturé, puis peser le total en dollars contre le temps que vous passez à rendre le résultat utilisable.
Ces chiffres sont une estimation de planification à partir des prix standard pour contexte court publiés par OpenAI, en supposant une entrée inférieure à 272 000 tokens par requête. Ils excluent les hits et écritures de cache, les frais d'outils, les prix batch, Fast, Ultrafast ou de fenêtre d'arrière-plan (y compris les remises), les majorations régionales, les taxes, les frais de plateforme et le temps de revue ou d'édition humaine. Ce ne sont pas un devis ToAPIs ; consultez le catalogue de modèles et la page de tarifs pour les tarifs en direct de votre compte.
5. Comment choisir en trois étapes
- Commencez par Sol. Exécutez la vraie tâche, ou un petit échantillon de celle-ci, via Sol avec votre prompt de production et vos règles de sortie. Enregistrez si chaque résultat passe, combien d'appels il a fallu et combien de temps vous avez passé à le réparer.
- Essayez Astra sur les échecs précis. Si Sol échoue pour une raison qu'un modèle plus fort pourrait corriger — instructions ambiguës, jugement de conception faible, étape visuelle difficile — exécutez les mêmes entrées via Astra. Ne déplacez pas toute la charge de travail parce qu'une démo semblait meilleure.
- Comparez le coût total des appels et le temps d'édition. Additionnez chaque appel facturé au prix par appel de chaque modèle, puis placez à côté le temps passé à relire ou réparer la sortie. Ne choisissez Astra que lorsque son coût d'appel supplémentaire est couvert par moins de nouvelles tentatives, moins d'édition ou un coût d'erreur plus faible.
Pour l'intégration API, utilisez le catalogue de modèles, la page de tarifs et la documentation API. Pour les ID de modèle et une première requête, voir le guide de l'API GPT-6.2 qui accompagne cet article. Consultez le catalogue en direct pour les variantes, tarifs et régions disponibles sur votre compte ; cet article n'affirme pas de tarifs, chemins d'endpoint ou couverture régionale spécifiques à la plateforme.
6. Questions fréquentes
Astra vaut-il 4x le prix ?
Seulement quand la qualité incrémentale change suffisamment le résultat pour justifier la prime. Pour un travail routinier et bien spécifié, Sol est difficile à battre. Pour des livrables à forte valeur, des changements de code coûteux ou des échecs répétés de Sol, Astra peut être moins cher par tâche réellement utilisable malgré le tarif de tokens plus élevé.
Le prix plus bas de Sol signifie-t-il une qualité inférieure en programmation ?
OpenAI rapporte Sol à 0,5 point d'Astra sur FrontierCode 2.0 pour environ un cinquième du coût (les deux au maximum). C'est une affirmation de l'éditeur, pas un résultat pour votre dépôt. Testez l'applicabilité des patches, le taux de réussite des tests, l'effort de revue et le risque de régression.
Comment comptabiliser l'entrée en cache ?
L'entrée en cache coûte $0.40 par million chez Astra contre $8.00 sans cache ; Sol est à $0.10 contre $2.00. Les écritures de cache sont distinctes. Si vous réutilisez de longs prompts ou documents, mesurez le taux de réussite du cache plutôt que de supposer des prix sans cache. L'exemple suppose aucun bénéfice de cache.
Et les prompts longs au-delà de 272K tokens ?
Calculez-les séparément. Au-delà de 272 000 tokens d'entrée, les tarifs d'entrée et de cache doublent et la sortie coûte 1,5x le tarif de contexte court pour toute la requête. La relation 4:1 des tarifs catalogue demeure, mais les coûts absolus augmentent ; gardez le travail en contexte long hors des estimations de contexte court.
Puis-je utiliser ToAPIs pour exécuter cette comparaison ?
Le catalogue international ToAPIs liste Astra et Sol, mais cet article n'affirme pas de tarifs, endpoints ou couverture régionale spécifiques à la plateforme. Consultez le catalogue en direct et la page de tarifs. Le harnais de comparaison de l'annexe développeur cible par défaut l'API officielle OpenAI ; si vous utilisez un autre endpoint compatible OpenAI, confirmez les ID de modèle, les champs et les unités de facturation.
7. Sources et méthode
- OpenAI: Introducing GPT-6.2 Astra and Sol, publié le 17 novembre 2026 — positionnement de lancement, disponibilité et résultats rapportés par l'éditeur.
- Page de modèle OpenAI : GPT-6.2 Astra — ID de modèle, limites de contexte, modalités, outils et tarifs, vérifiés le 18 novembre 2026.
- Page de modèle OpenAI : GPT-6.2 Sol — ID de modèle, limites de contexte, modalités, outils et tarifs, vérifiés le 18 novembre 2026.
- Tarifs de l'API OpenAI — conditions standard, cache, contexte long, batch, Fast et Ultrafast, vérifiées le 18 novembre 2026.
- ToAPIs : guide de l'API GPT-6.2 — configuration et tarifs spécifiques à la plateforme ; article complémentaire.
Note de méthode. Les montants en dollars sont de l'arithmétique déterministe à partir des tarifs catalogue publiés et des hypothèses de tokens et de tentatives de l'exemple. Ce ne sont pas des factures, des devis ou des résultats mesurés. Aucune inférence de modèle, mesure de latence, notation de qualité ou revue à l'aveugle n'a été réalisée pour cet article, et le harnais de comparaison de l'annexe développeur n'a pas été exécuté. Remplacez les tarifs, les nombres de tokens et les nombres de tentatives par vos propres données pilotes avant de prendre une décision de production.
Annexe développeur : exécutez votre propre comparaison
Le protocole suivant est conçu pour produire des preuves pour votre propre charge de travail. Il n'est délibérément pas un classement. La comparaison n'a pas été exécutée pour cet article, et aucune sortie de modèle ni chiffre de latence n'est rapporté ici.
Conception du test
- Figer le jeu de tâches. Utilisez 20 à 50 cas représentatifs, dont des cas faciles qui protègent le comportement existant et des cas difficiles qui distinguent les modèles. Supprimez les données confidentielles ou remplacez-les par des équivalents synthétiques.
- Figer la requête. Utilisez le même prompt système, la même entrée utilisateur, les mêmes outils, le même schéma de sortie et le même budget de tokens pour les deux modèles partout où les contrats le permettent. Enregistrez les différences inévitables.
- Répéter les tâches non déterministes. Conservez la distribution et les échecs, pas seulement la meilleure sortie.
- Noter à l'aveugle. Retirez l'étiquette du modèle avant la revue. Une tâche ne passe que si elle passe tous les contrôles requis ; une réponse soignée qui omet un champ, invente un identifiant ou échoue à un test est un échec.
- Compter les tentatives facturées et séparer la latence. Les tentatives échouées appartiennent au numérateur du coût lorsqu'elles sont facturées. Rapportez séparément le temps jusqu'au premier token, le temps d'achèvement et le temps jusqu'à un résultat accepté, et précisez ce que le chronomètre inclut.
Un jeu de cas minimal peut ressembler à ceci :
| Cas | Tâche | Contrôles d'acceptation |
|---|---|---|
extract-01 | Extraire l'article et la quantité d'un court message de commande | JSON valide ; clés exactes ; la quantité est un entier ; aucune valeur inventée |
code-01 | Implémenter une fonction avec des conditions limites | Le patch s'applique ; les tests passent ; l'entrée invalide est rejetée ; aucun changement non lié |
clarify-01 | Répondre à une demande de statut de commande sans ID de commande | Demande l'ID ; n'en invente pas ; aucune action d'écriture |
memo-01 | Transformer un pack de sources fourni en note d'une page | Chaque section requise présente ; chiffres traçables à la source ; aucune affirmation non étayée |
Le harnais appelle l'endpoint officiel Chat Completions d'OpenAI avec les deux ID de modèle, enregistre l'usage, la latence, les identifiants de modèle demandés et renvoyés et les horodatages, et laisse accepted à un relecteur humain. Il exige une clé d'API et ne fait des appels facturables qu'avec --execute. estimate_cost ignore les hits de cache, les remises par mode de facturation et les frais de plateforme ; réconciliez donc avec l'usage facturé. N'utilisez pas de données de production ; ne supposez pas qu'un agrégateur préserve les ID de modèle ou les tarifs.
#!/usr/bin/env python3
"""Reusable GPT-6.2 Astra vs Sol comparison harness.
The comparison was not executed for the accompanying article. Requires OPENAI_API_KEY and
explicit --execute consent because calls are billable. Acceptance is manual.
"""
from __future__ import annotations
import argparse
import json
import os
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path
API_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
MODELS = ("gpt-6.2-astra", "gpt-6.2-sol")
RATES = {
"gpt-6.2-astra": {"input": 8.00, "output": 40.00},
"gpt-6.2-sol": {"input": 2.00, "output": 10.00},
}
CASES = [
{
"id": "extract-01",
"system": "Return only valid JSON with exactly the keys item and quantity.",
"user": "Please order 3 blue mugs.",
"rubric": ["valid JSON", "item is blue mugs", "quantity is the integer 3"],
},
{
"id": "code-01",
"system": "Return a unified diff only. Do not include commentary.",
"user": (
"Implement merge_intervals(intervals) so overlapping or adjacent "
"intervals are merged. Reject invalid ranges. Include tests."
),
"rubric": ["patch applies", "tests pass", "invalid ranges rejected"],
},
{
"id": "clarify-01",
"system": "You are an order-support agent. Never invent identifiers.",
"user": "Where is my order?",
"rubric": ["asks for order ID", "does not invent an ID", "no write action"],
},
]
def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
rate = RATES[model]
return (
prompt_tokens * rate["input"] + completion_tokens * rate["output"]
) / 1_000_000
def call_model(model: str, case: dict) -> dict:
body = json.dumps(
{
"model": model,
"messages": [
{"role": "system", "content": case["system"]},
{"role": "user", "content": case["user"]},
],
"max_completion_tokens": 8000, # fixed cap for this comparison
}
).encode("utf-8")
request = urllib.request.Request(
API_URL,
data=body,
headers={
"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
"Content-Type": "application/json",
},
)
started = time.perf_counter()
with urllib.request.urlopen(request, timeout=180) as response:
payload = json.load(response)
elapsed = time.perf_counter() - started
usage = payload.get("usage", {})
prompt_tokens = usage.get("prompt_tokens", 0)
completion_tokens = usage.get("completion_tokens", 0)
return {
"requested_model": model,
"returned_model": payload.get("model"),
"api_url": API_URL,
"timestamp_utc": datetime.now(timezone.utc).isoformat(),
"case_id": case["id"],
"run": None,
"latency_seconds": round(elapsed, 3),
"prompt_tokens": prompt_tokens,
"completion_tokens": completion_tokens,
"cost_usd": round(estimate_cost(model, prompt_tokens, completion_tokens), 6),
"output": payload["choices"][0]["message"]["content"],
"rubric": case["rubric"],
"accepted": None,
"reviewer": None,
"review_notes": None,
}
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--execute", action="store_true", help="make billable API calls")
parser.add_argument("--repeats", type=int, default=1)
parser.add_argument("--out", default="gpt-6-2-runs.jsonl")
args = parser.parse_args()
if not args.execute:
print("Dry plan only. Re-run with --execute after checking access, budget and data rules.")
for case in CASES:
print(json.dumps({"case": case["id"], "models": MODELS, "repeats": args.repeats}))
return
if not os.environ.get("OPENAI_API_KEY"):
raise SystemExit("Set OPENAI_API_KEY first.")
output = Path(args.out)
with output.open("a", encoding="utf-8") as handle:
for case in CASES:
for model in MODELS:
for run in range(args.repeats):
record = call_model(model, case)
record["run"] = run + 1
handle.write(json.dumps(record, ensure_ascii=False) + "\n")
print(json.dumps({
"case_id": record["case_id"],
"model": record["requested_model"],
"latency_seconds": record["latency_seconds"],
"cost_usd": record["cost_usd"],
}))
print(f"Wrote {output}. Fill 'accepted' manually against each rubric before comparing costs.")
if __name__ == "__main__":
main()
Après revue, calculez le chiffre central de la décision de routage :
import json
from pathlib import Path
rows = [json.loads(line) for line in Path("gpt-6-2-runs.jsonl").read_text().splitlines()]
if not rows or any(type(row["accepted"]) is not bool for row in rows):
raise SystemExit("Review every row before comparing costs.")
for model in sorted({row["requested_model"] for row in rows}):
model_rows = [row for row in rows if row["requested_model"] == model]
accepted = sum(row["accepted"] is True for row in model_rows)
estimated = sum(row["cost_usd"] for row in model_rows)
per_accepted = estimated / accepted if accepted else None
print(model, {"accepted": accepted, "estimated_usd": round(estimated, 4),
"cost_per_accepted": round(per_accepted, 4) if per_accepted is not None else None})
Le harnais ne teste pas l'exécution d'outils, car exécuter du code ou des commandes shell générés par le modèle introduit des problèmes de sécurité et de reproductibilité. Si votre workflow utilise des outils, évaluez la trace d'outils séparément : arguments valides, autorisation, effets de bord, nouvelles tentatives, et si une question de clarification était la bonne action. Un modèle qui écrit une réponse parfaite mais appelle mal un outil destructif n'a pas réussi la tâche.







