Le constat (terrain) : les gains ne viennent pas du “prompt”
Tu peux avoir les meilleurs prompts du monde. Si ton IA n’est branchée sur un processus, des données et des contrôles, tu obtiens surtout… des démos.
C’est exactement ce qu’on observe chez ceux qui passent à l’échelle. Dans les banques comme BNP Paribas, le discours public est “plateforme interne + gouvernance + cas d’usage en production”, pas “prompt engineering”. Côté BPCE, même logique : l’agentique est présenté comme une étape d’industrialisation (outillage, intégration dans les parcours, multi-modèles), pas comme une collection d’expériences isolées.
Et ça se voit dans les signaux d’adoption : BPCE communique sur une utilisation massive de son outil interne “MAiA” (50% des 100 000 collaborateurs, environ 40 usages par mois en moyenne) et sur des automatisations en prod comme des voicebots capables de traiter 1 million d’appels de bout en bout. Ce ne sont pas des “prompts”. Ce sont des workflows outillés.
Avant de démarrer : un agent IA, c’est quoi (vraiment) ?
Un agent IA n’est pas une baguette magique. C’est un système qui enchaîne :
- des appels à un modèle (LLM),
- des outils (API, CRM, ERP, GED, RPA, bases internes),
- un orchestrateur (règles, étapes, mémoire, reprises sur erreur),
- et des contrôles (qualité, sécurité, traçabilité).
Le produit à piloter, ce n’est pas “le modèle”. C’est le workflow complet.
Point important dirigeant : les coûts et les risques se logent dans l’exécution du workflow (nombre d’étapes, appels modèles, accès aux outils, escalades humaines). Gartner anticipe que le coût d’inférence par workflow agentique peut augmenter de plus de 5x d’ici 2028. Moralité : tu ne pilotes pas “un agent”. Tu pilotes un workflow mesurable.
Le playbook “workflow IA mesurable” en 8 étapes
Objectif : déployer un agent IA en PME sans te perdre en POC, et industrialiser l’IA dans les processus avec des KPI, des garde-fous et une trajectoire d’extension.
Étape 1 : Choisir un processus, pas une idée
La mauvaise entrée : “on veut un agent IA entreprise pour être moderne”.
La bonne entrée : “on veut réduire le délai, l’effort, ou les erreurs sur un flux précis”.
Critères simples pour choisir :
- Volume : tâches répétées chaque semaine (ou chaque jour).
- Propriétaire métier : une personne responsable du résultat, pas un “on”.
- Données accessibles : documents, tickets, emails, ERP, CRM.
- Risque maîtrisable : si l’IA se trompe, tu peux rattraper avant impact client/financier.
- Point de douleur réel : retards, backlogs, double saisie, contrôles chronophages.
Décision dirigeant : tu nommes un sponsor métier + un sponsor IT/sécurité. Sans binôme, ça part en vrille (soit “gadget”, soit “non” permanent).
Étape 2 : Définir l’output mesurable (avant l’outil)
Si tu ne sais pas mesurer la sortie, tu ne sauras pas si tu as gagné.
Définis un output qui se vérifie en 30 secondes. Exemples :
- “Une note de crédit structurée au format interne + sources citées”.
- “Un dossier ADV complet prêt à être saisi, avec champs remplis + anomalies listées”.
- “Une réponse support interne avec procédure, lien doc, et niveau de confiance”.
Puis fixe 2 ou 3 métriques, pas 12 :
- Temps de cycle (délai entre entrée et sortie).
- Taux de reprise (combien de sorties doivent être corrigées).
- Qualité perçue (score simple par l’utilisateur final).
Ne promets pas un ROI magique. Tu cherches un gain net après “taxe de vérification”. Si tu veux cadrer ce point, lis : https://jimmymanin.com/blog/taxe-de-verification-eviter-que-lia-te-fasse-perdre-du-temps-pas-en-gagner
Étape 3 : Cartographier données et droits (le nerf de la guerre)
Les agents échouent rarement à cause du modèle. Ils échouent parce que :
- les données sont éparpillées,
- les droits sont flous,
- personne ne sait ce qui a été consulté,
- la confidentialité est traitée “après”.
Fais une cartographie en 45 minutes :
- Entrées : où arrive la demande (mail, formulaire, ticket, GED, CRM).
- Sources : où l’agent va lire (SharePoint/Drive, ERP, base qualité, wiki).
- Écritures : où l’agent a le droit d’écrire (brouillon mail, ticket, ERP, CRM).
- Données sensibles : clients, finances, RH, santé, secrets industriels.
- Journalisation : logs obligatoires (qui a fait quoi, quand, avec quelles données).
Décision dirigeant : “least privilege”. L’agent n’a pas besoin de tout voir. Il a besoin de voir juste ce qu’il faut.
Pour cadrer RGPD/agentique sans y passer des semaines : https://jimmymanin.com/blog/ia-agentique-en-entreprise-la-checklist-rgpd-avant-de-connecter-un-agent-a-vos-outils
Étape 4 : Sélectionner l’outillage (orchestrateur + connecteurs + garde-fous)
Tu ne choisis pas “ChatGPT vs Claude vs Gemini”. Tu choisis une chaîne de prod :
- Interface (où les équipes déclenchent et relisent).
- Orchestration (workflow, états, reprises sur erreur, files d’attente).
- Connecteurs (CRM/ERP/GED, email, ticketing, bases).
- Contrôles (modération, filtrage, policy, redaction/anonymisation si besoin).
- Observabilité (logs, traces, coûts, taux d’échec).
Deux patterns robustes :
- RPA + agent : RPA pour cliquer/saisir (déterministe), agent pour lire/synthétiser/qualifier (probabiliste).
- Agent “lecture seule” au départ : il prépare, il ne pousse pas en prod tant que tu n’as pas confiance.
Point dirigeant : attention au coût. Le budget se pilote par tâche, pas “au token” dans le vide. Guide utile : https://jimmymanin.com/blog/cout-dun-agent-ia-en-2026-chiffrer-par-tache-sans-te-faire-pieger-par-le-token
Étape 5 : Définir le niveau d’autonomie (et l’escalade)
L’erreur classique : passer de “assistant” à “agent qui agit” trop vite.
Utilise un modèle simple en 3 niveaux :
- Niveau 1 : l’agent propose, l’humain exécute.
- Niveau 2 : l’agent exécute dans un bac à sable, l’humain valide la sortie.
- Niveau 3 : l’agent exécute en production, avec exceptions et contrôles renforcés.
Décision dirigeant : tu fixes noir sur blanc ce que l’agent a le droit de faire. Et quand il doit s’arrêter.
Tu peux t’appuyer sur : https://jimmymanin.com/blog/agents-ia-le-modele-3-niveaux-dautonomie-pour-automatiser-sans-provoquer-lincident
Étape 6 : Mettre les contrôles (qualité, sécurité, traçabilité)
Deloitte rapporte qu’environ 80% des organisations n’ont pas de gouvernance mature pour des agents (frontières d’autonomie, monitoring temps réel, audit trail). Résultat : tu as des “agents partout”, mais personne ne sait ce qu’ils font.
Ton socle minimal :
- Qualité : critères de validation (structure, sources, complétude, cohérence).
- Sécurité : accès, secrets, tokens, séparation des environnements.
- Traçabilité : logs exploitables (pas juste “ça a marché”).
- Gestion des incidents : quoi faire si l’agent envoie n’importe quoi ou accède à trop large.
Deux risques à prendre au sérieux :
- Shadow agent : des automatisations agentiques apparaissent dans des outils “approuvés” sans validation centrale. Gartner note que 61% des responsables cyber seniors ont observé ce type d’automatisation dans des logiciels d’entreprise, et 59% suspectent (ou ont des preuves) d’usages non sanctionnés.
- Fuite de données : un connecteur mal cadré, et tu exportes de la donnée sensible sans t’en rendre compte.
Pour un plan de contrôle rapide avant de “laisser cliquer” : https://jimmymanin.com/blog/agents-ia-et-incidents-reels-le-plan-de-controle-en-30-minutes-avant-de-laisser-cliquer
Pour une checklist sécurité avant déploiement : https://jimmymanin.com/blog/agents-ia-en-entreprise-checklist-securite-en-12-points-anti-fuite-avant-deploiement
Étape 7 : Piloter par KPI (et pas par “impression”)
Un workflow IA mesurable se pilote comme une ligne de production. Tu veux :
- Un tableau de bord simple : volumes traités, temps moyen, taux de reprise, taux d’escalade.
- Un suivi coûts : coût par dossier/ticket, pics, dérives.
- Un suivi risques : incidents, near-miss, accès refusés, prompts suspects.
Règle pratique : si tu ne peux pas expliquer en 2 minutes “qu’est-ce qui s’améliore” et “qu’est-ce qui dégrade”, tu n’industrialises pas. Tu subis.
Pour cadrer les dérapages de budget sans bloquer les équipes : https://jimmymanin.com/blog/budgets-ia-qui-derapent-piloter-tokens-licences-et-depassements-sans-bloquer-tes-equipes
Étape 8 : Étendre (seulement quand c’est stable)
L’extension, ce n’est pas “dupliquer l’agent partout”. C’est :
- standardiser ce qui marche (templates, prompts encadrés, règles, connecteurs),
- mutualiser la gouvernance (droits, logs, revues),
- prioriser les prochains processus par impact et risque.
Tu veux éviter deux pièges :
- Agent sprawl : 25 agents, 0 visibilité, 0 maîtrise.
- POC éternel : ça “impressionne” mais rien ne tient la charge.
Si tu veux un cadre de déploiement court et contrôlé : https://jimmymanin.com/blog/agents-ia-en-entreprise-le-plan-pilote-controle-en-21-jours-sans-ouvrir-les-vannes
3 mini-exemples concrets (sans pipeau, sans chiffres inventés)
1) Notes de crédit : de “lecture de dossier” à “note structurée + risques”
Processus : analyse d’un dossier (bilans, Kbis, échanges, pièces justificatives) pour produire une note interne.
Output mesurable : une note au format attendu (sections fixes), avec :
- résumé exécutif,
- points d’attention et incohérences,
- liste des pièces manquantes,
- sources citées (document, page, extrait).
Données et droits : accès lecture seule aux dossiers, interdiction d’écrire dans le SI crédit au début.
Niveau d’autonomie : Niveau 1 puis Niveau 2 (brouillon validé par analyste).
Contrôles : obligation de citer les sources, test anti-hallucinations sur des cas “pièges” (documents contradictoires).
2) Traitement ADV : réduire la double saisie, augmenter la complétude
Processus : commande client reçue par email/PDF, création de commande dans ERP, vérification tarifs, délais, conditions.
Output mesurable : un “dossier de saisie” avec champs ERP pré-remplis + anomalies détectées :
- référence produit ambiguë,
- adresse incomplète,
- incoterm manquant,
- prix hors grille.
Outillage : IDP (extraction doc) + agent pour interpréter, classer, demander une clarification, puis RPA ou API pour pousser dans l’ERP quand c’est stable.
Niveau d’autonomie : Niveau 2 longtemps (l’humain valide), puis bascule partielle sur Niveau 3 pour les commandes “sans anomalie”.
Contrôles : seuil de confiance, blocage automatique si champs critiques manquants, journal des modifications.
3) Support interne : réponses plus rapides, moins d’aller-retours
Processus : tickets IT/RH/ops (“comment je fais X ?”, “où est la procédure ?”, “qui valide ?”).
Output mesurable : une réponse en 3 blocs :
- résolution pas à pas,
- lien vers la doc officielle,
- quand escalader + à qui.
Données : base documentaire, procédures internes, historique des tickets résolus. Accès strict, car tu touches vite à des infos sensibles.
Niveau d’autonomie : Niveau 1 (proposition), puis automatisation de brouillons de réponse.
KPI : temps de première réponse, taux de réouverture, satisfaction interne.
Le kit de démarrage (à faire cette semaine)
- 1 processus choisi, avec un propriétaire métier nommé.
- 1 output mesurable (format figé) + 3 exemples “bons” et 3 “mauvais”.
- 1 cartographie entrées/sources/écritures + liste des données sensibles.
- 1 niveau d’autonomie décidé (souvent Niveau 1 au départ).
- 1 plan de contrôle : qualité, sécurité, logs, escalade.
- 3 KPI max, suivis chaque semaine.
Si tu fais ça, tu n’es plus en train de “tester des agents IA entreprise”. Tu commences à construire un workflow IA mesurable que tu peux piloter, sécuriser, et étendre. C’est là que l’IA arrête d’être un sujet de veille et devient un levier opérationnel.
