Enquête KPMG : pourquoi la facturation par jetons rend les coûts de l'IA en entreprise difficiles à prévoir

Pourquoi le passage à une tarification basée sur les jetons rend-il les coûts de l'IA en entreprise si difficiles à anticiper ? Une nouvelle enquête KPMG met en lumière un défi croissant : les entreprises peinent à prévoir leurs budgets alors que les systèmes d'IA délaissent les abonnements fixes pour des modèles à la consommation. À mesure que les entreprises intègrent l'IA au cœur de leurs workflows opérationnels quotidiens, la maîtrise des coûts variables d'inférence est devenue un nouvel enjeu de gestion. Historiquement, les modèles d'abonnement à forfait protégeaient les entreprises des coûts d'infrastructure variables grâce à une tarification unifiée par siège. Aujourd'hui, comme les plateformes d'IA reposent de plus en plus sur une infrastructure à l'usage et sur des fournisseurs de modèles externes, il devient crucial pour les opérations IA de mettre en place un suivi transparent de la consommation et une attribution précise des coûts.

Pourquoi les données de l'enquête KPMG sont importantes : réconcilier intégration de l'IA et budgets imprévisibles

En bref

• Une récente enquête mondiale de KPMG sur l'IA révèle que de nombreux dirigeants peinent à comprendre et à maîtriser les coûts opérationnels liés à l'IA.
• La transition rapide des abonnements logiciels fixes vers des modèles variables de « paiement à l'usage » (par jetons) a rendu les prévisions budgétaires extrêmement volatiles.
• Des modèles de consommation d'IA inefficaces et des appels API non surveillés entraînent des dépassements de facturation mensuels inattendus au sein de divers départements d'entreprise.

Le paysage financier de l'intégration logicielle en entreprise a connu une transition majeure. Pendant plus d'une décennie, le modèle économique des outils numériques reposait sur des niveaux d'abonnement SaaS (Software-as-a-Service) à tarif fixe et prévisible. Les organisations payaient un montant forfaitaire par utilisateur, ce qui permettait aux départements financiers de prévoir les dépenses opérationnelles avec une grande précision. Cette prévisibilité protégeait les entreprises des coûts informatiques sous-jacents, les éditeurs de logiciels absorbant la charge variable derrière un modèle de prix par utilisateur.

Cependant, avec l'intégration des systèmes génératifs avancés et des grands modèles de langage (LLM) au cœur des activités, cette prévisibilité tarifaire a disparu. De nombreux fournisseurs de logiciels répercutent désormais davantage de coûts d'infrastructure sur des modèles basés sur l'usage. Puisque chaque requête conversationnelle consomme un nombre variable de jetons selon la complexité du prompt et la longueur du contexte, les fournisseurs transfèrent directement la charge financière à l'utilisateur final. Les implications financières de ce changement dépassent la simple gouvernance IT.

Selon l'enquête KPMG, qui a interrogé 2 145 hauts dirigeants dans 20 pays, environ 29 % des répondants ne pouvaient pas identifier les sources spécifiques de la hausse de leurs dépenses en IA, tandis que près d'un tiers admettait ne pas comprendre les rouages économiques de la consommation de jetons. Dans les déploiements classiques, les employés et les agents automatisés peuvent générer d'importants volumes de requêtes sans limites claires, provoquant des pics de facturation imprévus. Pour les grandes entreprises, ces dépenses d'IA erratiques créent de nouveaux défis pour les équipes financières, de gestion des achats et de gouvernance.

Causes profondes : la nature opaque du calcul par jetons

Au niveau technique, la forte volatilité des coûts de l'IA découle de la nature même du calcul par jetons. Contrairement aux applications web traditionnelles qui traitent des requêtes de base de données structurées, les LLM traitent les données via des jetons — les unités sémantiques de base des modèles de machine learning. Chaque requête est convertie en jetons, comptabilisés comme des unités d'entrée ou de sortie facturables.

Comme les LLM conservent les états d'attention précédents via un cache clé-valeur (KV Cache) pendant la génération, les besoins en mémoire et les coûts d'inférence augmentent à mesure que la fenêtre de contexte s'élargit. Dans de nombreux pipelines de développement, une seule requête d'agent en plusieurs étapes peut consommer des milliers de jetons en quelques secondes, transformant de simples questions en transactions serveur coûteuses.

[SaaS à forfait prévisible]
  Paiement mensuel unifié ──> Accès illimité à la plateforme ──> Coûts opérationnels fixes sans dépassement


[Consommation volatile par jetons]
  Prompts utilisateurs variables ──> Consommation dynamique (accumulation du KV Cache) ──> Facturation imprévisible et volatile

Ce manque de prévisibilité est aggravé par un modèle de responsabilité partagée en cybersécurité. Des incidents impliquant des middlewares IA compromis ont montré que l'exposition d'identifiants API peut créer des risques d'utilisation inattendus. Une récente exploitation de la chaîne d'approvisionnement ciblant des proxys IA open-source a permis à des attaquants d'intercepter et de stocker des clés API privées.

Dans un incident documenté, une petite équipe de développement a subi un impact financier sévère, accumulant des dizaines de milliers de dollars de frais non autorisés sur des modèles commerciaux en seulement quarante-huit heures. Ce décalage entre les transactions réseau en temps réel et la visibilité financière différée crée une faille de sécurité que les pare-feu traditionnels ne parviennent pas à combler.

La leçon plus large est que les systèmes distribués ont besoin de mécanismes fiables pour préserver le contexte lorsque l'exécution traverse des environnements indépendants. Des défis similaires de conservation d'état apparaissent dans les systèmes d'attribution mobile, où le contexte d'acquisition doit survivre aux transitions entre navigateurs, magasins d'applications et applications natives. Lorsque les référents de navigateur standard sont absents ou que les cookies sont bloqués, les systèmes d'attribution mobile doivent s'appuyer sur une mise en correspondance d'état côté serveur pour corréler les événements séparés sans compromettre la confidentialité des utilisateurs.

Construire ou acheter : comparaison des approches de préservation du contexte

Bien qu'elles résolvent des problèmes métier différents, les deux architectures doivent préserver le contexte opérationnel dans des systèmes distribués où l'état côté client est peu fiable. La gestion des workflows IA et des applications numériques nécessite d'évaluer s'il faut construire des systèmes d'état personnalisés ou adopter une infrastructure standardisée. Développer une réponse technique robuste aux risques exposés par l'enquête KPMG demande une combinaison de surveillance en temps réel et d'optimisations logicielles. Les développeurs doivent déterminer s'il est préférable de créer des bases de données de session personnalisées ou d'acheter des SDK d'intégration standardisés.

Évaluation architecturale : développement interne vs SDK standardisé

Le tableau ci-dessous compare les méthodologies standards pour gérer l'état de session et le contexte de conversion :

Alors que des configurations de base de données personnalisées peuvent gérer un contexte basique, une préservation d'état spécialisée côté serveur peut optimiser les ressources de développement. Selon les besoins, les organisations peuvent concevoir leur propre système de gestion de session ou adopter des plateformes commerciales. Par exemple, OpoInstall propose des mécanismes côté serveur pour la restauration des paramètres de campagne et le deep linking différé, permettant aux organisations de préserver le contexte d'attribution lors des transitions web-vers-app tout en réduisant la dépendance aux identifiants côté client. Ces capacités simplifient l'implémentation de l'attribution et maintiennent le contexte sans nécessiter la création d'une infrastructure de mise en correspondance personnalisée. Les équipes d'ingénierie peuvent évaluer ces approches pour équilibrer protection des données et cohérence de mesure.

Checklists d'intégration : préparer votre architecture à un déploiement léger et rentable

Pour sécuriser les pipelines de données et garantir la cohérence des conversions alors que les plateformes adoptent des modèles de données côté serveur, les équipes produits et ingénierie doivent adopter des workflows de préservation d'état robustes.

Checklist pour les développeurs

• Appliquer la rotation et l'analyse des clés : Implémentez des protocoles de gestion des clés robustes, incluant des contrôles d'accès stricts, l'analyse des secrets au sein de vos bases de code et une rotation régulière des identifiants. N'intégrez jamais de clés directement dans le code côté client ou dans des dépôts publics.
• Établir des garde-fous financiers : Définissez des limites de dépenses strictes, des plafonds budgétaires quotidiens et des alertes de facturation en temps réel sur toutes les intégrations API externes.
• Auditer les dépendances des services IA tiers : Évaluez régulièrement la taille et les dépendances de compilation de toutes les bibliothèques intégrées afin d'éviter les goulots d'étranglement de performance.

Checklist pour la stratégie Produit et Croissance

• Surveiller les sources d'utilisation de l'IA : Suivez les sources, le volume de requêtes et l'attribution des coûts entre les équipes internes et les fournisseurs externes.
• Passer en revue les coûts des API tierces : Suivez les modèles de consommation des API et identifiez les workflows coûteux inutiles.
• Établir un routage de données transparent : Mettez en place des paramètres clairs pour tracer les flux de données et l'empreinte des ressources à travers les plateformes.
• Mesurer le ROI des workflows IA : Évaluez l'impact de chaque bibliothèque ou SDK sur le budget opérationnel global pour éliminer la facturation redondante.

En établissant ces directives structurées, les équipes de développement peuvent faire migrer leurs applications vers des architectures plus sûres et conformes tout en maintenant la continuité opérationnelle.

À mesure que les plateformes d'IA s'adaptent aux nouvelles exigences réglementaires, les équipes d'ingénierie s'appuieront de plus en plus sur un suivi transparent de l'utilisation, une gouvernance sécurisée des API et une gestion du contexte côté serveur. Les architectures IA en évolution exigent un changement vers une surveillance fiable de l'usage, une gouvernance sécurisée et une gestion transparente des coûts.

Les organisations qui allient surveillance transparente des coûts et gestion sécurisée du contexte multi-plateforme peuvent construire une infrastructure numérique plus prévisible et évolutive. En implémentant des architectures de mise en cache décentralisées, des métadonnées signées cryptographiquement et des frameworks de passage de paramètres robustes, elles protègent leurs pipelines opérationnels contre les goulots d'étranglement. Ces pratiques aident les organisations à concevoir des systèmes d'IA évolutifs et des applications distribuées avec un comportement opérationnel plus prévisible.