GPT-5.6 Sol contre Grok 4.5 contre Gemini 3.6 Flash : Concevoir des solutions plus performantes
GPT-5.6 Sol contre Grok 4.5 contre Gemini 3.6 Flash : arrêtez de vous demander quel modèle est le meilleur et créez un routeur d’agents qui envoie chaque requête au modèle le plus adapté.
Sources: GPT-5.6 Sol vs Grok 4.5 vs Gemini 3.6 Flash: Build a Smarter Agent Router
Les notes suivantes reconstituent une approche pratique pour aborder le sujet « GPT-5.6 Sol vs Grok 4.5 vs Gemini 3.6 Flash : Créer un routeur d’agents plus intelligent ». L’accent est mis sur les contrats, les vérifications et les placeholders de code à insérer, plutôt que sur une présentation motivante.
Cessez de vous demander quel modèle est le meilleur. Routez chaque tâche d’agent en fonction du risque, du contexte, des outils, de la taille du résultat et du coût total.
Lorsque vous travaillez sur l’étape « Cessez de vous demander quel modèle », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de maintenir l’honnêteté des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les flags fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Enregistrez l’ID de la demande, l’ID du modèle et le temps de latence à chaque appel. Sans ces traces, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
User request → One powerful model → Tools → Final answer
Task
↓
Classification and risk analysis
↓
Model selection
↓
Execution
↓
Validation
↓
Escalation when required
Les modèles qui sont acheminés
Lors de la phase d’acheminement des modèles, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Enregistrez l’ID de la demande, l’ID du modèle et le temps de latence à chaque appel. Sans cette trace, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
GPT-5.6 Sol
Lorsque vous travaillez sur l’étape GPT-5 6 Sol, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts volumineux. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité et non un processus embrouillé. Enregistrez l’ID de la demande, l’ID du modèle et le temps de latence à chaque appel. Sans cette trace, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
Prix pour les contextes longs GPT-5.6 Sol
Lors du travail sur l’étape à long contexte de GPT-5 6 Sol, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez les terminations partielles silencieuses. Enregistrez l’ID de la demande, l’ID du modèle et le temps de réponse à chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
Input: $10 per million tokens
Output: $45 per million tokens
Prix du Grok 4.5 à long contexte
Lors du travail sur l’étape à long contexte de Grok 4 5, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Journalisez l’ID de la requête, l’ID du modèle et le temps de latence pour chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application. Lors du travail sur l’étape à long contexte de Grok 4 5, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures.
Input: $4 per million tokens
Cached input: $0.60 per million tokens
Output: $12 per million tokens
Input: 100,000 tokens
Output: 10,000 tokens
Input: 50,000 tokens
Output: 50,000 tokens
Input tokens = 3 × output tokens
Total model and tool cost
─────────────────────────
Accepted completed tasks
Ce que le routeur doit évaluer
La méthode « Ce que le routeur doit évaluer » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec ainsi que la note de réversion avant d’élargir le champ d’étude. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Fixez l’interpréteur et le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les différences entre l’ordinateur portable et les environnements CI sont la cause la plus fréquente d’échecs silencieux dans les démos API.
1. Type de tâche
La phase du type de tâche 1 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des critères de succès et refusez toute mise en œuvre partielle silencieuse. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les écarts entre l’ordinateur portable et les outils CI sont la cause la plus fréquente de dysfonctionnements silencieux dans les démos API.
classification
extraction
repository_search
planning
implementation
debugging
architecture
migration
security_review
final_review
computer_use
2. Risque
La phase de risque 2 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration à des environnements partagés. Fixez l’interpréteur et le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les différences entre l’ordinateur portable et les environnements CI sont la cause la plus fréquente de dysfonctionnement silencieux dans les démonstrations API. La phase de risque 2 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours optimal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
Low:
Documentation, formatting, metadata, test generation
Medium:
Contained feature work, refactoring, ordinary bug fixes
High:
Authentication, payments, permissions, infrastructure,
database migrations, security-sensitive code
3. Taille du contexte
Pour la phase de taille de contexte 3, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
4. Taille attendue de la sortie
Pour l’étape de taille de sortie attendue 4, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
5. Outils requis
Pour l’étape des 5 outils requis, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le parcours passe de l’environnement de démonstration à des environnements partagés. Séparez la construction du client de la boucle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation. Pour l’étape des 5 outils requis, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours idéal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures.
6. Échecs antérieurs
Lors de l’étape des 6 Échecs antérieurs, notez d’abord les exigences du contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Enregistrez l’ID de la demande, l’ID du modèle et le temps de réponse pour chaque appel. Sans cette trace, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
Une politique de routage pratique
Lors de l’étape relative à une politique de routage pratique, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux éléments générés, définez des vérifications de succès, et refusez les terminations partielles silencieuses. Enregistrez l’ID de la demande, l’ID du modèle et le temps de latence à chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
Routage vers Gemini 3.6 Flash pour :
Lors du travail sur l’étape « Route to Gemini 3 », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le parcours passe de l’environnement de démonstration à des environnements partagés. Enregistrez l’ID de la requête, l’ID du modèle et le temps de latence pour chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application. Lors du travail sur l’étape « Route to Gemini 3 », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’améliorations ultérieures.
Route to Grok 4.5 pour :
La méthode pour atteindre la phase Grok 4 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de rollback avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les différences entre l’ordinateur portable et les environnements CI sont la cause la plus fréquente d’échecs silencieux lors des démonstrations API.
Voie vers GPT-5.6 Sol pour :
La méthode en 6 étapes vers GPT-5 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des critères de succès et refusez toute complétion partielle silencieuse. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les écarts entre l’ordinateur portable et les environnements CI sont la cause la plus fréquente de dysfonctionnement silencieux dans les démos API.
Implémentation de référence en TypeScript
La phase de mise en œuvre de référence de TypeScript fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et une note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’une démonstration à des environnements partagés. Fixez l’interpréteur et le fichier de verrouillage des dépendances avant d’aborder les boucles. Les différences entre l’ordinateur portable et les environnements CI constituent la cause la plus fréquente de dysfonctionnement silencieux dans les démonstrations API. La phase de mise en œuvre de référence de TypeScript fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et une note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives de réessai, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
type ModelId =
| "gpt-5.6-sol"
| "grok-4.5"
| "gemini-3.6-flash";
type TaskKind =
| "classification"
| "extraction"
| "repository_search"
| "planning"
| "implementation"
| "debugging"
| "architecture"
| "migration"
| "security_review"
| "final_review"
| "computer_use";
type RiskLevel = "low" | "medium" | "high";
interface AgentTask {
kind: TaskKind;
risk: RiskLevel;
estimatedInputTokens: number;
estimatedOutputTokens: number;
previousFailures: number;
requiresComputerUse?: boolean;
requiresXSearch?: boolean;
requiresMcp?: boolean;
}
interface ModelPricing {
inputPerMillion: number;
outputPerMillion: number;
cachedInputPerMillion?: number;
contextWindow: number;
longContext?: {
threshold: number;
inputPerMillion: number;
outputPerMillion: number;
cachedInputPerMillion?: number;
};
}
const MODEL_PRICING: Record<ModelId, ModelPricing> = {
"gpt-5.6-sol": {
inputPerMillion: 5,
outputPerMillion: 30,
cachedInputPerMillion: 0.5,
contextWindow: 1_050_000,
longContext: {
threshold: 272_001,
inputPerMillion: 10,
outputPerMillion: 45,
cachedInputPerMillion: 1,
},
},
"grok-4.5": {
inputPerMillion: 2,
outputPerMillion: 6,
cachedInputPerMillion: 0.3,
contextWindow: 500_000,
longContext: {
threshold: 200_000,
inputPerMillion: 4,
outputPerMillion: 12,
cachedInputPerMillion: 0.6,
},
},
"gemini-3.6-flash": {
inputPerMillion: 1.5,
outputPerMillion: 7.5,
contextWindow: 1_000_000,
},
};
function estimateCost(
model: ModelId,
inputTokens: number,
outputTokens: number,
): number {
const pricing = MODEL_PRICING[model];
if (inputTokens + outputTokens > pricing.contextWindow) {
throw new Error(
`${model} context window exceeded: ` +
`${inputTokens + outputTokens} tokens`,
);
}
const activePricing =
pricing.longContext &&
inputTokens >= pricing.longContext.threshold
? pricing.longContext
: pricing;
return (
(inputTokens / 1_000_000) *
activePricing.inputPerMillion +
(outputTokens / 1_000_000) *
activePricing.outputPerMillion
);
}
function chooseModel(task: AgentTask): ModelId {
// Hard tool requirements come first.
if (task.requiresXSearch) {
return "grok-4.5";
}
if (task.requiresMcp) {
return "gpt-5.6-sol";
}
// Escalate tasks that repeatedly fail.
if (task.previousFailures >= 2) {
return "gpt-5.6-sol";
}
// High-risk work receives stronger reasoning or review.
if (
task.risk === "high" ||
task.kind === "architecture" ||
task.kind === "migration" ||
task.kind === "security_review" ||
task.kind === "final_review"
) {
return "gpt-5.6-sol";
}
// Gemini is suitable for routine UI automation.
if (
task.requiresComputerUse ||
task.kind === "computer_use"
) {
return "gemini-3.6-flash";
}
// Large prompts can make Grok's long-context tier
// less attractive.
if (task.estimatedInputTokens >= 200_000) {
return "gemini-3.6-flash";
}
// Output-heavy coding tasks can favour Grok.
const inputToOutputRatio =
task.estimatedInputTokens /
Math.max(task.estimatedOutputTokens, 1);
if (
task.kind === "implementation" ||
task.kind === "debugging"
) {
return inputToOutputRatio < 3
? "grok-4.5"
: "gemini-3.6-flash";
}
// Cheap default for low-risk, input-heavy work.
return "gemini-3.6-flash";
}
function routeTask(task: AgentTask) {
const model = chooseModel(task);
const estimatedCost = estimateCost(
model,
task.estimatedInputTokens,
task.estimatedOutputTokens,
);
return {
model,
estimatedCost,
reason: buildRoutingReason(task, model),
};
}
function buildRoutingReason(
task: AgentTask,
model: ModelId,
): string {
if (task.requiresXSearch) {
return "Task requires native X search.";
}
if (task.previousFailures >= 2) {
return "Escalated after repeated failures.";
}
if (task.risk === "high") {
return "High-risk task requires stronger reasoning.";
}
if (task.estimatedInputTokens >= 200_000) {
return "Large input makes long-context pricing relevant.";
}
if (model === "grok-4.5") {
return "Output-heavy coding task.";
}
return "Low-risk, input-heavy agent task.";
}
Ajouter une validation avant l’escalade
Pour l’étape d’ajout d’une validation avant escalade, définissez les entrées, le responsable de cette étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
interface RunResult {
model: ModelId;
success: boolean;
inputTokens: number;
outputTokens: number;
toolCalls: number;
testsPassed?: boolean;
lintPassed?: boolean;
typecheckPassed?: boolean;
changedFiles: string[];
estimatedCost: number;
latencyMs: number;
failureReason?: string;
}
function shouldEscalate(result: RunResult): boolean {
if (!result.success) return true;
if (result.testsPassed === false) return true;
if (result.lintPassed === false) return true;
if (result.typecheckPassed === false) return true;
return false;
}
Utiliser une échelle d’escalade
Pour utiliser une étape d’échelle d’escalade, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute complétion partielle silencieuse. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
Low-risk agent task
Gemini 3.6 Flash
↓ failure
Grok 4.5
↓ failure
GPT-5.6 Sol
Grok 4.5
↓ failed tests or repeated loop
GPT-5.6 Sol
GPT-5.6 Sol implementation
↓
Independent review by another model
↓
Automated checks
↓
Human approval
Séparer la planification, l’exécution et l’évaluation
Pour l’exécution et la phase de planification distinctes, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le parcours passe d’un environnement de démonstration à des environnements partagés. Séparez la construction du client de la boucle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation. Pour l’exécution et la phase de planification distinctes, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours idéal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et la gestion des messages non livrés font partie du produit, et non plus ultérieurement.
Polissage.Processus de codage économe en coûts
Lors de la phase du processus de codage économe en coûts, notez d’abord les exigences du contrat : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables aux scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Enregistrez l’ID de la demande, l’ID du modèle et le temps de réponse pour chaque appel. Sans cette trace, les erreurs intermittentes du fournisseur ressemblent à des bugs de l’application.
Gemini 3.6 Flash
→ Gather repository context
→ Classify the task
→ Identify relevant files
Grok 4.5
→ Implement the change
→ Run tests
→ Repair ordinary failures
GPT-5.6 Sol
→ Review only if risk is high
→ Resolve ambiguous failures
Processus de migration à haut risque
Lors de la phase du flux de travail de migration à haut risque, notez d’abord les conditions du contrat : les données requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Considérez cette phase comme un contrat entre les données d’entrée et les résultats validés. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez toute exécution partielle silencieuse. Enregistrez l’ID de la demande, l’ID du modèle et le temps de réponse pour chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur sont prises pour des bugs de l’application.
GPT-5.6 Sol
→ Design the migration plan
→ Identify rollback requirements
Grok 4.5
→ Implement isolated migration steps
GPT-5.6 Sol
→ Review the patch and failure modes
Automated pipeline
→ Test, lint, scan and stage
Human reviewer
→ Approve production execution
Créer un ensemble de données d’évaluation à partir de travaux réels
Lors de la phase de création d’un ensemble de données d’évaluation, notez d’abord les conditions prévues : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le système passe de l’environnement de démonstration à des environnements partagés. Journalisez l’ID de la requête, l’ID du modèle et le temps de latence pour chaque appel. Sans ce suivi, les erreurs intermittentes du fournisseur sont prises pour des bugs de l’application. Lors de la phase de création d’un ensemble de données d’évaluation, notez d’abord les conditions prévues : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives de réexécution, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement.
Task category
Selected model
Input and output tokens
Tool calls
Latency
Retries
Estimated cost
Test result
Human corrections
Files reverted
Final acceptance status
Escalation path
Cost par tâche acceptée
L’étape du coût par tâche acceptée fonctionne le mieux lorsqu’elle est considérée comme une mesure quantifiable. Recueillez un exemple réussi exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité et non un processus embrouillé. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’expliquer la boucle. Les différences entre l’ordinateur portable et l’environnement CI sont la cause la plus fréquente d’échecs silencieux lors des démonstrations API.
Total cost, including retries
─────────────────────────────
Number of accepted tasks
Taux de réussite à la première tentative
La phase du taux de réussite à la première tentative fonctionne le mieux lorsqu’elle est considérée comme une mesure quantitative. Capturez un exemple de réussite exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des critères de succès et refusez toute mise en œuvre partielle silencieuse. Fixez l’interpréteur ainsi que le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les écarts entre l’ordinateur portable et les environnements CI sont la cause la plus fréquente de dysfonctionnement silencieux dans les démos API.
Tasks accepted without retry
────────────────────────────
Total tasks
Délai de correction par un humain
La phase de correction par un humain fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés. Fixez l’interpréteur et le fichier de verrouillage des dépendances avant d’enseigner la boucle. Les différences entre l’ordinateur portable et les environnements CI constituent la cause la plus fréquente de dysfonctionnement silencieux dans les démonstrations API. La phase de correction par un humain fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours optimal et le parcours de récupération. Les tentatives de réessai, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure.
Taux de changements inutiles
Pour l’étape de taux de changement inutile, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
Le routeur doit rester remplaçable
Afin que le routeur reste dans cette phase, il convient de définir les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définites des vérifications de succès et refusez toute complétion partielle silencieuse. Séparez la construction du client du cycle de messages afin que les fournisseurs puissent être remplacés sans avoir à réécrire la machine d’état de la conversation.
Gemini is always cheap.
Grok is always best for implementation.
Sol is always the strongest.