Tu veux “un agent”. Tu risques d’obtenir un prototype ingérable.
Le scénario classique : quelqu’un te montre une démo. L’agent “peut” lire tes mails, “peut” mettre à jour le CRM, “peut” préparer des réponses. Sur le papier, c’est magique. En vrai, c’est vite incontrôlable : accès trop larges, actions non traçables, coûts qui dérivent, qualité inégale, et au premier incident tu coupes tout.
Ce n’est pas un problème de techno. C’est un problème de méthode de déploiement.
Les chiffres récents confirment le terrain : beaucoup d’entreprises testent des agents, mais peu les laissent tourner sans supervision humaine. Gartner parle de 75% qui pilotent ou déploient “une forme d’agents IA”, et seulement 15% qui envisagent/pilotent/déploient des agents pleinement autonomes. Traduction dirigeant : ton objectif réaliste, c’est un agent outillé, borné, traçable, avec validation humaine.
Voici un plan en 21 jours. Simple. Exécutable. Et pensé pour éviter le “agent sprawl” : dix mini-agents bricolés par dix personnes, zéro gouvernance, et des accès partout.
La règle de base : un agent utile, ce n’est pas un chatbot
Définition opérationnelle (celle qui évite les mauvaises surprises) : un agent, c’est un système qui suit un objectif, appelle des outils (CRM, Drive, ERP, tickets…), prend des décisions locales (règles), exécute des actions, et laisse des traces. Et il passe en validation humaine dès que ça devient risqué.
Sans outils + permissions + logs + supervision, tu n’as pas un agent. Tu as une démo.
Le plan “pilote contrôlé” en 21 jours
Objectif : mettre un seul workflow en production contrôlée, avec garde-fous, métriques, et une décision Go/No-Go claire. Pas une vitrine. Un truc qui tourne dans ton entreprise sans te mettre en stress.
Semaine 1 (Jours 1 à 7) : cadrer un seul workflow et verrouiller le périmètre
Jour 1 : choisir LE workflow (pas “un agent”)
Tu choisis un processus qui coche 4 cases :
- Fréquent (tous les jours ou toutes les semaines).
- Assez standard (des règles, des cas typiques).
- Données accessibles (pas un enfer de qualité data dès le départ).
- Risque maîtrisable (si ça se trompe, ça ne met pas le feu à la boîte).
Exemples réalistes en pilote IA PME : tri et pré-qualification de demandes entrantes, préparation de réponses support niveau 1 avec validation, mise en forme de compte-rendus, création de brouillons d’emails commerciaux à partir du CRM, enrichissement de fiches tickets.
Évite en pilote : paiement, suppression, clôture automatique de dossiers, actions irréversibles, modifications massives du CRM.
Jour 2 : écrire la “carte du workflow” en 30 minutes
Tu poses le flux sur une page :
- Entrées : quelles infos déclenchent le workflow.
- Étapes : 5 à 9 étapes max.
- Sorties : ce que l’agent produit (brouillon, classement, recommandation, action).
- Points de contrôle : où un humain valide.
Règle : si tu ne peux pas le résumer clairement, tu n’es pas prêt à déployer un agent IA dessus.
Jour 3 : décider le niveau d’autonomie (et le figer)
Tu fixes un niveau dès le départ, sinon ça glisse.
- Niveau 0 : l’agent propose, l’humain fait tout.
- Niveau 1 : l’agent prépare et exécute seulement des actions réversibles, avec validation sur le reste.
- Niveau 2 : l’agent exécute des actions plus “business”, mais avec garde-fous serrés, logs, et monitoring.
Pour un pilote contrôlé, vise Niveau 0 ou 1. Tu veux apprendre, pas prouver que tu es “agentic”.
Si tu veux structurer ça proprement : https://jimmymanin.com/blog/agents-ia-le-modele-3-niveaux-dautonomie-pour-automatiser-sans-provoquer-lincident
Jour 4 : lister les systèmes à connecter (et en couper la moitié)
Tu fais la liste des outils que “ça serait cool” de connecter. Puis tu réduis à 2 systèmes max pour le pilote (exemple : Gmail + CRM, ou outil tickets + base de connaissance).
Pourquoi : chaque connecteur, c’est un risque (droits, fuite, coûts, incident). Les incidents IA deviennent un sujet opérations, pas juste IT. Tu veux minimiser la surface d’attaque et la surface d’erreur.
Jour 5 : décider quelles données l’agent a le droit de voir
Tu écris une règle simple :
- Ce qui est autorisé (types de documents, champs CRM, tickets).
- Ce qui est interdit (RH, finance sensible, pièces d’identité, médical, etc.).
- Ce qui doit être anonymisé ou masqué.
Si tu bosses en UE, garde en tête que “petit pilote” ne veut pas dire “hors conformité”. Et ça finit en prod plus vite que prévu.
Jour 6 : définir les “actions interdites”
Liste noire stricte dès le départ. Par exemple :
- Envoi d’email externe sans validation.
- Modification d’un montant, d’un RIB, d’une adresse de facturation.
- Suppression de données.
- Clôture automatique de ticket.
Tu pourras desserrer plus tard. Pas maintenant.
Jour 7 : écrire les critères Go/No-Go (avant de construire)
Sinon tu vas t’attacher au prototype et tu vas le pousser “parce qu’on a déjà investi”.
Exemples de critères :
- Qualité : au moins X% de réponses jugées “utilisables” avec retouches mineures.
- Temps : gain net de Y minutes par dossier (après relecture, pas “sur le papier”).
- Risque : 0 action interdite réalisée, 0 fuite de données détectée.
- Traçabilité : 100% des exécutions loggées et retrouvables.
- Coût : coût moyen par dossier inférieur à un seuil.
Semaine 2 (Jours 8 à 14) : construire l’agent outillé, traçable, avec garde-fous
Jour 8 : mettre en place l’identité et les permissions “au plus juste”
La règle dirigeant : l’agent n’a pas de super-pouvoirs. Il agit avec l’identité et les droits d’un rôle dédié, limité.
- Un compte de service ou un rôle “Agent-Pilote”.
- Accès en lecture seule quand c’est possible.
- Accès en écriture uniquement sur un périmètre (ex : un pipeline CRM “à valider”).
Approche recommandée : identity-first. Si tu es dans l’écosystème Microsoft, pense Entra ID et audit. Si tu utilises Copilot Studio, active ce qui permet logs, transcriptions, audit via Purview selon ton contexte de licences.
Jour 9 : imposer la traçabilité (logs, transcripts, traces)
Sans logs, tu ne pilotes rien. Tu subis.
Minimum viable :
- Qui a déclenché l’agent.
- Quelles sources ont été lues.
- Quelles actions ont été proposées.
- Quelles actions ont été exécutées.
- Quelle validation humaine a eu lieu, par qui.
Si tu construis plus “sur-mesure”, garde l’idée de traces bout en bout : appels LLM, appels outils, garde-fous, handoffs.
Jour 10 : poser les garde-fous de contenu (anti-hallucination utile)
Tu ne cherches pas la réponse “brillante”. Tu veux une réponse contrôlable.
- Obligation de citer la source interne utilisée (lien vers doc, ticket, champ CRM).
- Si pas de source, obligation de dire “je ne sais pas” + demander l’info.
- Format standard (ex : 3 propositions max, 5 lignes max).
Si tu veux une méthode rapide de garde-fous : https://jimmymanin.com/blog/agents-ia-en-entreprise-eviter-le-faux-signalement-garde-fous-en-60-minutes
Jour 11 : définir les points de validation humaine (et les rendre obligatoires)
Tu crées des “portes” :
- Draft only : l’agent prépare, un humain envoie.
- Queue de validation : l’agent propose, un humain approuve dans un outil (CRM, ticketing).
- Seuils : au-delà d’un montant, d’un type client, d’un mot-clé (litige, RGPD…), validation obligatoire.
Ça te permet d’avoir de la vitesse sans lâcher le volant.
Jour 12 : limiter les coûts et la dérive
Un agent “qui réfléchit trop” devient une facture et une latence.
- Plafond de tokens / budget par exécution.
- Timeout et arrêt propre.
- Cache sur les infos stables (FAQ, policies).
- Interdiction des boucles (max 3 appels outil).
Jour 13 : écrire les scénarios de test (10 cas réels, pas des cas parfaits)
Tu prends 10 dossiers du vrai monde :
- 3 cas simples.
- 4 cas moyens.
- 3 cas tordus (données incomplètes, client énervé, contradiction).
Tu définis ce qui est “bon”, “acceptable”, “dangereux”.
Besoin d’un protocole pour éviter l’IA qui “cache ses erreurs” : https://jimmymanin.com/blog/ia-qui-cache-ses-erreurs-le-protocole-dirigeant-5-tests-avant-dautomatiser
Jour 14 : mettre en place le monitoring opérationnel
Tu veux pouvoir répondre à ces questions en 2 minutes :
- Combien d’exécutions aujourd’hui ?
- Combien bloquées par validation ?
- Combien d’erreurs ?
- Combien ont touché des données sensibles ?
- Coût total et coût moyen ?
Semaine 3 (Jours 15 à 21) : pilote réel, gouvernance minimale, décision Go/No-Go
Jour 15 : lancer le pilote sur un périmètre réduit
Tu choisis :
- 1 équipe ou 3 à 5 utilisateurs max.
- 1 type de demandes (pas tout le support).
- 1 canal (email OU tickets, pas les deux si tu débutes).
Objectif : apprendre vite, sans exposer toute l’entreprise.
Jour 16-17 : faire tourner, mesurer, corriger
Tu fais un rituel quotidien de 15 minutes :
- 5 exécutions prises au hasard, relues à froid.
- 1 erreur analysée (pourquoi, comment éviter).
- 1 règle ajoutée ou ajustée (pas 10).
Sinon tu finis avec un monstre de règles incompréhensible.
Jour 18 : checklist “gouvernance IA” minimale (pilotable en PME)
Tu ne vas pas implémenter ISO 42001 au complet en 3 semaines. Par contre, tu peux prendre l’esprit PDCA et le concret du NIST AI RMF : rôles, documentation, oversight humain, mesure continue.
Checklist minimale :
- Owner métier : responsable du résultat (qualité, délais, valeur).
- Owner technique : responsable de la sécurité, des accès, des logs.
- Validation : qui a le dernier mot sur les changements.
- Registre du pilote : une fiche unique, versionnée (voir modèle plus bas).
- Politique données : ce qui est autorisé/interdit + durée de conservation des logs.
- Traçabilité : où sont les logs, qui y accède, combien de temps.
- Gestion incident : quoi faire si fuite, action non voulue, output risqué.
- Revue hebdo : métriques + décisions (on continue, on ajuste, on stop).
Complément utile côté sécurité avant déploiement : https://jimmymanin.com/blog/agents-ia-en-entreprise-checklist-securite-en-12-points-anti-fuite-avant-deploiement
Jour 19 : décider ce qui passe en production “élargie” (et ce qui reste interdit)
Tu définis un plan d’élargissement :
- Plus d’utilisateurs, oui, mais pas plus de droits d’un coup.
- Plus de volume, oui, mais avec seuils et quotas.
- Plus d’autonomie, seulement si les métriques tiennent 2 semaines.
Tu évites le piège : “ça marche sur 20 dossiers, donc on branche tout”. C’est comme ça qu’on ouvre les vannes trop vite.
Jour 20 : faire la revue Go/No-Go (avec une décision binaire)
Réunion de 45 minutes. Agenda :
- Métriques vs objectifs.
- Incidents et quasi-incidents.
- Charge de validation humaine (la fameuse taxe de vérification).
- Coûts et dérive.
- Décision : Go, Go avec restrictions, No-Go.
Si tu veux cadrer la “taxe de vérification” : https://jimmymanin.com/blog/taxe-de-verification-eviter-que-lia-te-fasse-perdre-du-temps-pas-en-gagner
Jour 21 : documenter et verrouiller la suite
Tu produis 3 livrables simples :
- La fiche pilote finalisée.
- La liste des garde-fous (règles, actions interdites, validations).
- Le plan 30 jours : élargissement ou arrêt.
Modèle de fiche de pilote (copie-colle)
- Nom du pilote : Agent IA - [workflow]
- Objectif business : ex. réduire le temps de traitement des demandes entrantes de 30%
- Périmètre : équipe, canal, type de demandes
- Niveau d’autonomie : 0 / 1 / 2 (figé pour le pilote)
- Systèmes connectés : [outil 1], [outil 2]
- Données utilisées : sources autorisées + données exclues
- Actions autorisées : ex. créer un brouillon, tagger un ticket
- Actions interdites : ex. envoi externe, suppression, modification finance
- Validation humaine : où, quand, par qui
- Traçabilité : où sont les logs, durée de conservation, accès
- Risques principaux : fuite données, erreur client, non-conformité, réputation
- Garde-fous : sources obligatoires, format, seuils, quotas
- Métriques :
- Qualité (taux “utilisable”)
- Temps net gagné
- Taux de validation/refus
- Incidents/quasi-incidents
- Coût par dossier
- Critères Go/No-Go : seuils chiffrés
- Owners : métier, technique, sponsor
- Date de revue : J+21
Le point clé : tu ne déploies pas “un agent IA”, tu déploies un système contrôlé
Si tu veux des agents IA entreprise qui tiennent en production, tu fais l’inverse du réflexe “prototype rapide”. Tu cadres dur, tu connectes peu, tu logs tout, tu gardes l’humain dans la boucle, et tu prends une décision Go/No-Go sans état d’âme.
Prochaine action (30 minutes)
- Choisis un seul workflow.
- Écris la carte du workflow (entrées, étapes, sorties, validations).
- Liste 5 actions interdites.
- Fixe 3 métriques et 3 critères Go/No-Go.
Ensuite seulement, tu construis. C’est ça, la différence entre “pilote IA PME” utile et prototype ingérable.
