Le retrait de modèles GitHub Copilot transforme les évolutions de l’IA en gestion des mises en production
GitHub retirera six modèles Copilot le 14 décembre. Le risque ne tient pas seulement à leur disparition du sélecteur : prompts, comportement des agents, politiques, coûts et résultats des revues de code peuvent changer dans les workflows d’ingénierie.
Ce que GitHub retirera le 14 décembre

L’annonce publiée par GitHub le 13 novembre prévoit la dépréciation de six modèles dans toutes les expériences GitHub Copilot le 14 décembre 2026 : Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon, Grok 4.6 et Kimi K3. Le périmètre dépasse le sélecteur de modèles de Copilot Chat. GitHub inclut explicitement Copilot Chat, les modifications inline, le mode ask, le mode agent et les complétions de code. Une même date de retrait peut donc modifier la manière dont les développeurs posent leurs questions, changent du code sur place, délèguent le travail sur un dépôt et reçoivent des suggestions pendant l’édition. (GitHub Changelog)
L’avis propose une alternative pour chaque entrée, mais ne présente pas ce changement comme un remplacement universel, strictement équivalent, que tous les comptes vivraient de la même manière. Claude Fable 5 doit passer à Claude Fable 5.2. Claude Haiku 4.5 est associé à Claude Haiku 5.5. Gemini 3.8 Flash est associé à Gemini 4 Hydrogen, et Gemini 4 Argon à Gemini 4 Carbon. Pour Kimi K3, le tableau de GitHub indique que l’alternative est « À annoncer » : les organisations qui utilisent ce modèle ne disposent donc pas encore, dans cette annonce, d’un successeur nommé à valider.
Ce dernier point a une importance opérationnelle. Une équipe peut commencer immédiatement à tester les alternatives nommées, mais elle ne peut pas considérer l’entrée Kimi K3 comme une correspondance finalisée. La destination reste indéterminée dans l’avis de retrait, ce qui laisse une décision distincte à prendre pour tout workflow dépendant de la sélection ou de la disponibilité de Kimi K3. La documentation de GitHub sur les modèles pris en charge rappelle également que leur disponibilité dépend du forfait Copilot et de l’endroit où Copilot est utilisé, par exemple GitHub.com ou un environnement de développement intégré. GitHub précise que cette disponibilité peut évoluer lorsque des modèles sont remplacés ou mis à jour. La présence d’un modèle dans un client ou un compte ne prouve donc pas, à elle seule, qu’il est disponible partout où l’équipe travaille. (GitHub Docs)
Claude Haiku 4.5 fait l’objet d’une exception précise dans l’annonce. Il restera disponible pour les abonnés individuels à GitHub Copilot ayant souscrit un forfait annuel, et GitHub indique que la dépréciation ne s’applique pas à ces clients. Cette précision doit être interprétée strictement : elle désigne une catégorie d’abonnés individuels, et non une exemption générale pour toutes les organisations ou tous les comptes qui utilisent par hasard une facturation annuelle. Pour les autres utilisateurs, Claude Haiku 4.5 reste l’un des modèles dont la dépréciation est prévue le 14 décembre, Claude Haiku 5.5 étant présenté comme l’alternative suggérée.
L’avis de GitHub explique aussi le traitement des alternatives suggérées pour les clients Copilot Enterprise et Copilot Business lorsque l’activation des modèles par défaut est utilisée. Les alternatives sont activées automatiquement lorsque le paramètre par défaut correspondant est actif, sauf si un administrateur a désactivé le paramètre global par défaut ou désactivé explicitement le modèle. Si l’organisation a désactivé ce paramètre global, un administrateur peut autoriser l’accès aux alternatives au moyen des politiques de modèles dans les paramètres de Copilot. Une fois activé, le modèle apparaît dans le sélecteur de modèles de Copilot Chat, dans les expériences Copilot prises en charge. GitHub indique qu’aucune action n’est nécessaire pour supprimer les modèles retirés après leur dépréciation, mais cela ne dispense pas de mettre à jour les workflows et les intégrations avant la date prévue.
Cette distinction — activation automatique avec une configuration de politique, contre action explicite de l’administrateur avec une autre — explique pourquoi l’échéance du 14 décembre doit être traitée comme un point de contrôle de configuration et de gestion des mises en production. Les noms des modèles peuvent apparaître à différents endroits : dans la sélection d’un utilisateur, dans les politiques de modèles de l’organisation ou de l’entreprise, ou dans une intégration qui suppose la présence d’un modèle pris en charge. Un utilisateur qui vérifie uniquement l’interface de discussion peut manquer un paramètre de politique ou une dépendance de workflow ; un administrateur qui active seulement les alternatives suggérées peut ne pas comparer leur comportement sur les tâches réellement effectuées par l’équipe.
L’inventaire immédiat est donc concret. Déterminez si l’un des six modèles retirés est utilisé dans Copilot Chat, les modifications en ligne, le mode ask, le mode agent ou les complétions de code ; notez quel forfait Copilot et quel client régissent chaque usage ; puis distinguez les remplacements nommément indiqués des cas encore non résolus. Claude Fable 5, Claude Haiku 4.5, Gemini 3.8 Flash, Gemini 4 Argon et Grok 4.6 disposent de destinations suggérées dans l’annonce de GitHub. Kimi K3 n’en a pas encore, tandis que les abonnés individuels à un forfait annuel sont explicitement exemptés de la dépréciation de Claude Haiku 4.5. Ces éléments délimitent la migration à venir : il faudra vérifier que la destination prise en charge convient au workflow d’ingénierie, plutôt que de supposer qu’un changement de libellé de modèle est purement cosmétique.
Pourquoi un changement de modèle peut modifier le résultat d’une équipe d’ingénierie
Un modèle Copilot fait partie d’un workflow d’ingénierie ; ce n’est pas seulement un libellé dans un sélecteur. Lorsque GitHub remplace un modèle retiré, la tâche environnante peut sembler identique tandis que le comportement du système évolue en profondeur. La requête provient toujours du même éditeur ou du même dépôt, mais le modèle de remplacement peut interpréter les instructions différemment, demander d’autres précisions, choisir une séquence d’outils différente ou s’arrêter à un autre moment dans une boucle d’agent. Ces écarts comptent lorsqu’une tâche dépend d’une convention précise du dépôt plutôt que d’une réponse globalement acceptable.
C’est pourquoi l’avis de retrait doit être traité comme un événement de gestion des versions. Les surfaces concernées comprennent Copilot Chat, les modifications en ligne, les modes ask et agent, ainsi que les complétions de code. Une modification sur l’une de ces surfaces peut changer la manière dont une instruction devient du code, la façon dont les fichiers existants sont parcourus avant une modification ou la quantité de contexte mobilisée pour justifier un changement proposé. La question pratique n’est pas de savoir si le modèle de remplacement peut produire du code, mais s’il produit le code attendu, dans le dépôt attendu, avec les mêmes permissions et les mêmes contraintes de politique.
La requête ne constitue qu’une partie du contrat
Les équipes considèrent souvent une requête comme une demande de réponse : corriger un test défaillant, refactoriser une fonction, expliquer une API ou examiner une pull request. Les workflows Copilot mûrs ajoutent à cette demande un contrat implicite. Le modèle est censé suivre les instructions du dépôt, préserver le style local, respecter le périmètre, utiliser correctement les outils disponibles et fournir un résultat qu’un réviseur humain peut vérifier. Un changement de modèle peut toucher chacune de ces couches, même si la requête écrite reste inchangée.
L’interprétation de la requête est la première source de variation. Un modèle peut comprendre que « appliquez cette modification dans tout le module » inclut les tests associés ; un autre peut ne modifier que la fonction nommée. L’un peut considérer une instruction concise comme une autorisation d’examiner les fichiers voisins, tandis que l’autre demandera confirmation avant d’élargir la recherche. Ces comportements ne sont pas nécessairement défectueux, mais ils modifient le nombre de décisions laissées au développeur. Une équipe qui s’est appuyée discrètement sur l’interprétation d’un modèle peut découvrir que ses requêtes étaient moins explicites que ne le supposait son processus.
L’utilisation des outils constitue une deuxième différence. En mode agent, la qualité du résultat dépend non seulement du texte final, mais aussi du chemin suivi pour l’obtenir : quels fichiers sont ouverts, quelles commandes sont proposées ou exécutées, si un test est lancé et comment le modèle réagit à une erreur. Un modèle de remplacement qui utilise moins d’appels d’outils peut être plus rapide, mais laisser des hypothèses importantes sans vérification. Un autre, qui multiplie les appels, peut améliorer l’analyse des tâches difficiles tout en consommant davantage de jetons et en prenant plus de temps. La documentation de GitHub sur les modèles pris en charge précise également que leur disponibilité dépend du forfait Copilot et de la surface où Copilot est utilisé, et qu’elle peut évoluer lorsque des modèles sont remplacés ou mis à jour. Le workflow effectif associe donc modèle, surface produit et politique — pas seulement un nom de modèle.
De petits écarts de comportement peuvent devenir des changements de workflow
Le style de code est un autre signal visible. Les modèles peuvent différer dans leur propension à refactoriser, l’emplacement choisi pour les fonctions utilitaires, la manière de nommer les variables et leur décision de préserver un schéma existant ou d’en introduire un nouveau. Pour une suggestion isolée, cela peut relever d’une simple préférence. À travers des complétions répétées ou des modifications en ligne, ces écarts peuvent accroître le bruit lors des revues et rendre les conventions d’une base de code moins homogènes. Il en va de même pour les commentaires et les tests : des tests générés plus larges peuvent être utiles, mais ils peuvent aussi étendre les différences au-delà de ce qu’un réviseur attendait.
La latence et la consommation de jetons doivent faire partie de la même évaluation. Une réponse techniquement correcte, mais sensiblement plus lente, peut modifier la volonté des développeurs d’utiliser Copilot pour les petites tâches. Une réponse qui consomme davantage de contexte ou produit des différences plus longues peut également influencer les habitudes d’utilisation et les mécanismes de contrôle des coûts. L’avis de retrait ne permet pas d’établir un résultat précis en matière de performances ou de coûts pour chaque modèle de remplacement : ces effets doivent donc être mesurés, et non présumés.
La qualité des revues mérite une attention distincte, car il s’agit d’une tâche de jugement, pas seulement de génération de code. Un modèle de remplacement peut mettre l’accent sur d’autres risques, formuler ses observations différemment ou ne pas détecter un défaut relevé par le modèle précédent. Il peut aussi repérer un problème jusque-là négligé. « Le code compile toujours » ne constitue donc pas un test de migration suffisant. Avant de considérer que la couverture d’une procédure de revue inchangée est restée la même, les équipes devraient comparer des résultats représentatifs : problèmes relevés, explications, faux positifs et omissions.
L’étude de migration prévue en 2026 dans le plan de recherche ajoute un avertissement sur le calendrier : son analyse a constaté que la plupart des migrations observées dans les applications open source avaient eu lieu après l’arrêt du modèle d’origine. Ce constat fournit un contexte, et non une prédiction selon laquelle tous les utilisateurs de Copilot réagiront de la même manière. Sa conséquence opérationnelle est simple : attendre l’application effective du retrait supprime la période pendant laquelle une équipe peut comparer les résultats, alors que l’ancien comportement est encore disponible comme référence. Tester en amont transforme ainsi un changement inattendu en production en comparaison maîtrisée.
Le modèle mental le plus sûr est celui de la compatibilité comportementale, et non de la compatibilité des noms de modèles. La documentation de GitHub peut préciser quels modèles et quelles politiques sont pris en charge, mais elle ne peut pas démontrer qu’un remplacement préservera l’interprétation des invites, la boucle de l’agent, le style, la latence, l’utilisation des jetons ou la qualité des revues propres à une équipe. Ces caractéristiques doivent être vérifiées sur les tâches que l’équipe réalise réellement. Un retrait de modèle devient gérable lorsque les responsables techniques traitent le remplacement comme un changement de version dans une chaîne d’outils d’ingénierie assistée par l’IA, puis valident les éléments dont dépendent les utilisateurs, l’automatisation et les politiques.
Qui doit agir avant la date limite
La date limite n’est pas seulement un rappel destiné aux développeurs individuels. C’est aussi une question de responsabilité : qui contrôle le choix du modèle, qui dépend du comportement actuel et qui peut vérifier qu’un remplacement reste adapté au flux de travail ? L’avis de retrait de GitHub couvre Copilot Chat, les modifications en ligne, les modes ask et agent, ainsi que les complétions de code. Le public concerné est donc plus large que les personnes qui ouvrent occasionnellement un sélecteur de modèle. Les administrateurs d’entreprise, les équipes plateforme, les responsables de dépôts et les développeurs peuvent chacun contrôler une partie différente de la configuration.
Les administrateurs d’entreprise devraient commencer par les politiques qui déterminent quels modèles les utilisateurs peuvent voir et utiliser. La distinction essentielle oppose un modèle sélectionné explicitement à un modèle par défaut hérité des paramètres de l’organisation. Un modèle nommé peut figurer dans une politique, une norme documentée, une instruction enregistrée ou une intégration, même si la plupart des utilisateurs découvrent Copilot au travers d’un modèle par défaut. Ces références doivent être repérées avant la date de retrait. Un modèle par défaut peut être modifié de manière centralisée, tandis qu’un choix explicite peut rester intégré à un flux de travail ou échouer lorsque le modèle nommé n’est plus disponible.
La revue administrative doit également couvrir l’éligibilité du forfait et les restrictions qui concernent les modèles de remplacement. La documentation de GitHub sur les modèles pris en charge fait de la disponibilité et des contrôles de politique des éléments à prendre en compte dans la sélection d’un modèle ; il ne faut donc pas déduire cette disponibilité du compte d’un autre utilisateur ou d’une capture d’écran du produit. Vérifiez le forfait Copilot de l’organisation, les modèles autorisés par la politique, ainsi que les exigences éventuelles en matière de résidence des données ou de conformité qui réduisent le choix disponible. Si un remplacement n’est pas accessible avec un forfait donné ou entre en conflit avec une restriction organisationnelle, le parcours de migration peut différer de celui suggéré par une annonce générale.
Les équipes plateforme ont une responsabilité distincte : repérer les endroits où Copilot fait partie d’un système d’ingénierie plutôt que d’être un simple outil individuel. Cela inclut les paramètres de modèle épinglés dans des extensions ou des intégrations, les fichiers d’instructions partagés, les consignes internes destinées aux développeurs, l’automatisation des pull requests et les tâches d’évaluation qui enregistrent les résultats sous le nom d’un modèle. Une référence de modèle peut être dissimulée dans une valeur de configuration, une règle de politique ou un banc de test. Inventorier ces références permet de distinguer une valeur par défaut choisie délibérément d’une dépendance susceptible de tomber en panne ou de changer silencieusement.
La priorité doit aller aux workflows qui ont une conséquence opérationnelle. Après un changement de modèle, les modes agent peuvent interpréter les prompts, utiliser des outils, répéter des étapes et s’arrêter dans des conditions différentes. Les workflows de revue de code peuvent produire des constats, des niveaux de priorité ou des explications différents, même lorsque le code sous-jacent n’a pas changé. Les évaluations automatisées peuvent elles aussi devenir trompeuses si elles comparent les résultats d’un modèle à des résultats historiques obtenus avec un autre, sans consigner le changement. Ces possibilités ne prouvent pas qu’un remplacement échouera ; elles montrent que ce remplacement doit avoir un responsable et faire l’objet d’un contrôle.
Les équipes doivent recenser chaque workflow qui suppose l’utilisation d’un modèle nommé, et pas seulement ceux qui en affichent un. Un développeur qui choisit un modèle pour obtenir ponctuellement une explication devra peut-être seulement vérifier qu’un remplacement pris en charge est disponible. En revanche, une équipe plateforme qui exécute des tâches agent, de l’assistance à la revue ou des évaluations reproductibles de prompts doit définir ce que signifie « équivalent » pour ce workflow et déterminer qui approuvera le résultat. Les contrôles pertinents peuvent porter sur l’exactitude pour des tâches représentatives, le comportement des appels d’outils, la latence, l’utilisation des tokens, les autorisations et la qualité des revues.
Les développeurs ont eux aussi un rôle concret à jouer avant la bascule. Ils doivent examiner les prompts enregistrés, les instructions personnelles, les paramètres de l’éditeur et les préférences de modèle documentées qu’ils utilisent au quotidien. Ils doivent également signaler les prompts ou exemples d’équipe qui mentionnent un modèle retiré, en particulier lorsqu’ils sont copiés dans des dépôts partagés ou des supports d’intégration. Le fait qu’un remplacement soit visible dans l’interface ne signifie pas automatiquement qu’il a été validé pour les conventions de codage, les attentes en matière de tests ou les habitudes de revue d’un projet. Les développeurs sont souvent les mieux placés pour repérer ces différences discrètes, mais lourdes de conséquences.
Une règle d’escalade utile est simple : plus un workflow peut agir, bloquer ou publier, moins il est acceptable de considérer le retrait d’un modèle comme une simple mise à jour cosmétique de l’interface. Un workflow agent qui modifie des fichiers, un processus de revue qui influence les décisions de fusion ou un pipeline d’évaluation utilisé pour comparer des changements de prompts ont un impact opérationnel plus important qu’une session de chat ordinaire. Leurs responsables doivent consigner le modèle actuel, le remplacement prévu, la politique qui l’autorise et les éléments prouvant que le workflow reste acceptable après le changement.
Avant le 14 décembre, les administrateurs peuvent confirmer l’héritage des politiques et l’éligibilité des remplacements ; les équipes plateforme peuvent rechercher les configurations, intégrations, prompts et évaluations concernés ; et les développeurs peuvent tester les tâches Copilot récurrentes. L’objectif n’est pas de préserver un nom de modèle pour lui-même. Il s’agit de rendre la dépendance visible, d’attribuer la responsabilité du workflow concerné et de s’assurer que toute modification des résultats sera remarquée par les personnes qui s’y fient.
Une checklist de migration contrôlée pour les utilisateurs de Copilot
Considérez la bascule du 14 décembre 2026 comme un petit exercice de gestion des mises en production, même si GitHub la présente comme un changement de disponibilité des modèles. La première tâche consiste à établir où les modèles retirés sont effectivement référencés. Recherchez-les dans les politiques administrateur, la documentation des dépôts ou de l’organisation, les prompts enregistrés, les procédures internes, les scripts d’évaluation et les intégrations qui transmettent explicitement un nom de modèle. Consignez également les endroits où un modèle est sélectionné comme valeur par défaut plutôt que nommé dans du code ou une configuration. Le sélecteur de modèle visible ne représente qu’une partie de la surface de dépendance : une équipe peut avoir standardisé ses prompts, ses instructions agent ou ses procédures de revue autour d’un modèle particulier sans avoir documenté cette hypothèse.
L’inventaire doit attribuer un responsable et une décision à chaque référence. Le responsable peut approuver le remplacement proposé par GitHub, choisir un autre modèle pris en charge, ou supprimer le verrouillage explicite et laisser la politique applicable encadrer le choix. Cette décision doit tenir compte de l’éligibilité du forfait et des règles de l’organisation qui limitent les modèles utilisables. Elle doit également recenser les intégrations dont le comportement dépend de la disponibilité d’un modèle. Le fait qu’un remplacement apparaisse dans une interface utilisateur ne signifie pas qu’il soit automatiquement disponible pour tous les forfaits, périmètres de politique ou workflows. L’inventaire doit donc être confronté à la documentation actuelle de GitHub sur les modèles pris en charge ainsi qu’aux propres paramètres Copilot de l’organisation.
1. Rendre le remplacement explicite
Ne vous reposez pas sur un basculement silencieux pour les tâches d’ingénierie importantes. Activez ou approuvez explicitement le remplacement prévu dans les paramètres pertinents de l’organisation, de l’entreprise ou du compte personnel, puis vérifiez que ce réglage atteint bien les utilisateurs et les dépôts concernés. Si une politique est héritée, notez l’origine de sa valeur effective et les personnes habilitées à la modifier. C’est particulièrement important pour les administrateurs d’entreprise : la sélection locale d’un développeur peut ne pas remplacer une politique d’organisation, tandis qu’une modification centralisée peut affecter de nombreux workflows simultanément.
Pour chaque modèle nommé, consignez le comportement attendu après le changement. La fiche peut rester concise : modèle de remplacement, surfaces Copilot concernées, responsable de la politique, contrainte de forfait ou d’éligibilité, et comportement de repli si le remplacement est indisponible. Incluez les cas particuliers signalés dans l’avis de GitHub, au lieu de supposer que tous les comptes suivent le même parcours. L’objectif n’est pas de conserver un libellé particulier à tout prix, mais de rendre l’état après bascule volontaire et visible.
2. Tester des tâches représentatives, pas des prompts de démonstration
Constituez un jeu d’évaluation à partir des tâches réelles qui comptent pour l’équipe. Incluez la complétion de code courante, les modifications portant sur plusieurs fichiers, le débogage, l’explication, la génération de tests, la revue de code et tout workflow agentique utilisant des outils ou le contexte du dépôt. Conservez le prompt, les fichiers ou fixtures pertinents, le résultat attendu et les critères d’acceptation afin de comparer l’ancienne et la nouvelle configuration sur le même travail. Quelques démonstrations convaincantes ne suffisent pas à établir qu’une migration est sûre.
Évaluez d’abord la justesse, mais ne vous arrêtez pas là. Notez si la réponse respecte les conventions du dépôt, si elle demande des précisions au bon moment, si elle propose des changements inutiles et si un évaluateur peut comprendre le patch obtenu. Pour les modes agentiques, vérifiez la boucle complète : interprétation de la demande, sélection des outils, demandes d’autorisation, modifications des fichiers, exécution des tests et comportement d’arrêt. Ces vérifications découlent concrètement du fait que les modèles peuvent différer dans l’interprétation des prompts, l’utilisation des outils et le comportement agentique, même lorsqu’ils sont proposés via la même surface Copilot.
La latence et la consommation de tokens doivent figurer dans la même comparaison. Un modèle qui produit une réponse acceptable, mais prend plus de temps, consomme davantage de contexte ou entraîne des itérations supplémentaires peut modifier le coût et le débit d’un workflow. Recueillez suffisamment d’éléments pour distinguer une réponse isolée d’un phénomène reproductible. Si l’équipe dispose déjà d’évaluations automatisées, faites passer la migration par ces tests et conservez les résultats ; sinon, un petit ensemble examiné manuellement reste plus utile que l’hypothèse non vérifiée selon laquelle le remplacement serait équivalent.
3. Vérifier les autorisations, la politique et le comportement de repli
Un test de migration doit reproduire les autorisations dont disposera le workflow en production. Confirmez que le remplacement peut accéder au contexte de dépôt et aux outils attendus, et que les étapes d’approbation se comportent toujours comme prévu. Testez à la fois un parcours nominal et un parcours contraint : par exemple, que se passe-t-il lorsqu’un appel d’outil nécessite une approbation, lorsqu’un modèle n’est pas activé pour le compte ou lorsqu’une politique d’administrateur empêche une sélection privilégiée ? Le résultat doit être consigné comme un comportement opérationnel, plutôt que laissé aux développeurs, qui le découvriraient au cours d’une tâche réelle.
Documentez le comportement de restauration ou de repli avant l’échéance. Dans ce cas, la restauration ne signifie pas forcément remettre en service un modèle retiré ; il peut s’agir de basculer vers un autre modèle pris en charge, de désactiver une étape automatisée, d’orienter une tâche vers une revue humaine ou d’utiliser temporairement un processus plus ciblé. L’essentiel est que l’équipe sache quelle action est sûre lorsque le modèle attendu n’est plus disponible ou produit un résultat sensiblement différent. Ne considérez pas un repli non testé comme un mécanisme de contrôle : il peut modifier le style du code, la profondeur de la revue, la latence ou les habitudes d’utilisation, tout comme un remplacement principal.
4. Communiquer la bascule et la vérifier ensuite
Informez les développeurs, réviseurs et administrateurs concernés de ce qui change, de sa date d’entrée en vigueur et des processus qui nécessitent une attention particulière. La communication doit renvoyer vers le remplacement ou la règle approuvée, désigner le responsable à contacter et fournir les résultats de l’évaluation. Elle doit également préciser ce que les utilisateurs doivent signaler : modèles indisponibles, comportement inattendu de l’agent, modification des résultats de revue, nouvelles demandes d’approbation, latence inhabituelle ou hausse notable de l’utilisation. Des critères de signalement clairs permettent de distinguer plus facilement une différence normale entre modèles d’un défaut de configuration.
Après le 14 décembre, effectuez un contrôle post-changement au lieu de clore la tâche dès que l’échéance est passée. Vérifiez que les modèles retirés n’apparaissent plus là où ils ne devraient pas, que les remplacements prévus sont disponibles pour les bons comptes et que l’héritage des règles aboutit toujours à la valeur attendue. Relancez un petit sous-ensemble représentatif du jeu d’évaluation, examinez un ou plusieurs processus réels de revue de code et d’agent, puis comparez les indicateurs d’utilisation ou de coût avec la référence établie avant le changement. Enfin, mettez à jour les prompts enregistrés, les procédures opérationnelles et la documentation interne afin que la prochaine évolution de modèle parte d’un inventaire fiable. Cette dernière vérification transforme un retrait imposé en changement maîtrisé, avec un résultat observable.
Comments
Sign in to comment.
No comments yet.