Tu veux “automatiser”, pas créer un nouvel organe de risques
Microsoft a (re)découpé Copilot en trois expériences Home / Code / Autopilot (annonce officielle du 25 septembre 2026). Ce n’est pas du marketing cosmétique. C’est un changement de posture.
Home = chat assisté. Code = dev. Autopilot = délégation de tâches, plus autonome, dans ton environnement Microsoft 365.
Et là, le vrai sujet n’est pas “est-ce que l’IA répond bien ?”. Le sujet c’est “avec quels droits elle agit” et “combien ça te coûte quand ça tourne en volume”.
Autopilot est présenté par Microsoft comme vivant dans ton tenant, avec identité, mémoire, ordinateur et espace de travail, et avec des notions de permissions, audit, gouvernance. Traduction dirigeant : tu dois trancher avant de laisser l’outil exécuter.
Le tri utile : ce qui est automatisable vs ce qui doit rester assisté
Une règle simple avant de parler technique : automatisable ne veut pas dire autonome.
- Automatisable (souvent oui) : tri, classement, pré-remplissage, réponses niveau 1, extraction de données, consolidation, brouillons, création de tickets, mise à jour CRM, synthèses.
- À garder assisté (souvent non) : engagement légal, décisions de crédit, remises commerciales hors barème, paiement, modification de coordonnées bancaires, rupture de contrat, communication de crise, tout ce qui peut créer un incident irréversible.
Si tu veux un cadre “terrain” pour éviter l’incident avec des agents, garde sous la main le modèle des niveaux d’autonomie : https://jimmymanin.com/blog/agents-ia-le-modele-3-niveaux-dautonomie-pour-automatiser-sans-provoquer-lincident
La méthode en 9 décisions de dirigeant (avant de brancher Autopilot partout)
Décision 1. Tu poses le périmètre : “sur quoi Autopilot a le droit de bosser ?”
Tu listes 3 processus maximum au départ. Pas 15. Sinon tu crées du Shadow AI et de la dette de gouvernance.
Pour chaque processus, tu écris une phrase :
- Objectif business (temps gagné, SLA, réduction d’erreurs, cash).
- Entrées (emails, tickets, commandes, fichiers, Teams).
- Sorties (réponse client, ticket créé, facture préparée, rapport).
- Actions autorisées : lire, résumer, créer un brouillon, envoyer, modifier un fichier, créer un élément ERP, etc.
Si tu n’arrives pas à l’écrire en 10 lignes, ce n’est pas prêt pour Autopilot. Commence en assisté (Home).
Décision 2. Tu choisis le niveau d’autonomie : assisté, semi-autonome, autonome
Tu tranches par risque, pas par envie de “tout automatiser”.
- Assisté : Copilot propose, un humain exécute.
- Semi-autonome : Copilot exécute, mais soumis à validation avant envoi/écriture/paiement.
- Autonome : Copilot exécute sans validation sur des tâches réversibles (classement, routage, tagging, préparation).
Pour limiter les coûts cachés de contrôle qualité, lis aussi “taxe de vérification” : https://jimmymanin.com/blog/taxe-de-verification-eviter-que-lia-te-fasse-perdre-du-temps-pas-en-gagner
Décision 3. Tu définis les droits d’accès : le danger, c’est “l’IA agit avec des droits”
Autopilot dans ton tenant, c’est bien. Mais ça veut dire qu’il peut exploiter tes partages internes… y compris les mauvais. Les fuites “modernes” viennent souvent d’un SharePoint trop ouvert, pas d’un hacker.
Règle dirigeant : pas de nouveaux droits. Autopilot hérite d’une identité. Tu contrôles cette identité.
- Qui peut lire quoi ? (sites, bibliothèques, boîtes partagées)
- Qui peut écrire quoi ? (CRM, fichiers, tickets)
- Qui peut envoyer quoi ? (emails externes, Teams invités)
Avant de déployer des agents, utilise la checklist anti-fuite : https://jimmymanin.com/blog/agents-ia-en-entreprise-checklist-securite-en-12-points-anti-fuite-avant-deploiement
Décision 4. Tu imposes une gouvernance Copilot entreprise : qui peut créer, publier, modifier
Dans une PME, l’explosion ne vient pas du DSI. Elle vient de “5 personnes motivées” qui publient des agents sans garde-fou.
Tu veux une gouvernance Copilot entreprise simple :
- Owner (métier) : responsable du résultat et du risque.
- Admin (IT) : responsable des droits, logs, accès.
- Auteurs
Et tu décides : un agent = un propriétaire = un canal de support interne. Sinon, personne n’assume quand ça dérape.
Décision 5. Tu actives les logs et l’audit : “pas de traçabilité = pas d’autonomie”
Si Autopilot agit, tu dois pouvoir répondre à trois questions :
- Qui a déclenché ?
- Quoi a été lu et produit ?
- Quelle action a été faite (envoi, modification, création) ?
Exigence minimale : journal des actions + conservation (durée) + revue (qui regarde, à quelle fréquence).
Et oui : tes prompts peuvent devenir des preuves. Cadre-le : https://jimmymanin.com/blog/vos-prompts-peuvent-devenir-des-preuves-ce-que-tout-dirigeant-doit-cadrer
Décision 6. Tu imposes des points de validation humaine (les vrais, pas “au feeling”)
La validation humaine doit être déclenchée par règle, pas par intuition.
Exemples de règles simples :
- Si le message part à l’externe, validation obligatoire.
- Si le contenu touche à prix, remise, pénalité, validation obligatoire.
- Si la demande contient “RIB”, “IBAN”, “virement”, validation obligatoire + double validation.
- Si l’IA dépasse un seuil d’incertitude (ou si sources absentes), validation obligatoire.
Pour une mécanique “double validation” rapide (anti-fraude), tu as un protocole prêt : https://jimmymanin.com/blog/fraude-a-la-voix-deepfake-le-protocole-double-validation-en-30-minutes
Décision 7. Tu cadres la qualité : 5 tests anti-hallucinations avant de laisser agir
Autopilot peut produire vite, et faux. Surtout sur du reporting ou des réponses support basées sur des docs bancals.
Tu mets un protocole simple de test avant passage en semi-autonome :
- Test “sources” : l’IA cite les documents utilisés.
- Test “chiffres” : recalcul sur un échantillon.
- Test “cas tordus” : exceptions, clients VIP, cas litigieux.
- Test “contradictions” : deux documents qui disent l’inverse.
- Test “non réponse” : l’IA sait dire “je ne sais pas”.
Méthode prête ici : https://jimmymanin.com/blog/hallucinations-ia-le-protocole-simple-en-5-tests-pour-eviter-lerreur-qui-coute-cher
Décision 8. Tu pilotes le budget “usage-based” : fin du “prix par siège, point”
Avec l’arrivée de la facturation IA usage-based Microsoft via des Copilot Credits, ton risque numéro 1 sur des processus volumétriques (support, ADV, reporting) c’est l’emballement de consommation.
Deux chiffres utiles (documentés par Microsoft selon scénarios) :
- 0,01 USD par message sur certains meters pay-as-you-go (agents Copilot Chat / SharePoint agents via Azure).
- 0,12 USD par interaction (cas SharePoint agents en consommation, avec des “messages” sous-jacents).
Piège classique : raisonner “par prompt”. La facturation peut être “par interaction” composée de plusieurs briques (grounding, génération, etc.).
Ta décision : tu mets un plafond mensuel et des alertes dans le dashboard de cost management (spending policies, limites, contrôle par groupe/utilisateur). Pas après. Avant.
Mini-méthode de calcul (PME) :
- Tu estimes le volume (ex. 3 000 tickets/mois).
- Tu estimes l’interaction moyenne (ex. 2 interactions/ticket).
- Tu fais une fourchette (0,01 USD/message vs 0,12 USD/interaction selon ton setup).
- Tu fixes un plafond “safe” pour 30 jours de test.
Et tu fais une règle bête mais efficace : pas de modèle “reasoning” premium sur un flux volumique tant que tu n’as pas prouvé le ROI. Les modèles plus “intelligents” peuvent ajouter un compteur token-based (donc surcoût).
Décision 9. Tu définis des critères d’arrêt : tu coupes avant l’incident, pas après
Un Autopilot sans bouton stop, c’est une dette. Tu écris noir sur blanc :
- Critère coût : si dépassement de X crédits/semaine, pause automatique.
- Critère qualité : si taux de correction humaine dépasse Y %, retour en assisté.
- Critère risque : 1 incident confidentialité ou 1 envoi externe erroné, gel immédiat.
- Critère data : si sources non maîtrisées (SharePoint ouvert), pause tant que nettoyage pas fait.
Pour le garde-fou “agent qui dépense” (logique exactement comparable avec l’usage-based), garde ça : https://jimmymanin.com/blog/agent-ia-qui-depense-ton-argent-le-garde-fou-a-mettre-avant-de-tout-connecter
3 processus PME : ce que tu peux vraiment déléguer (et où mettre la barrière)
1) Support client (niveau 1)
Ce qui s’automatise bien :
- Classification du ticket (thème, urgence, produit).
- Réponse brouillon basée sur la base de connaissance.
- Demande automatique des infos manquantes (numéro client, version, capture).
- Création du ticket et routage vers la bonne équipe.
Ce qui doit rester assisté :
- Remboursement, geste commercial, reconnaissance de faute.
- Litiges, menaces juridiques, RGPD.
- Tout envoi externe sans validation si ton risque image est élevé.
Garde-fous coûts : le support, c’est du volume. Tu mets un plafond usage-based, et tu testes sur 10 à 20 % des tickets.
Si tu veux déjà une approche support “terrain”, tu peux aussi t’inspirer de : https://jimmymanin.com/blog/support-client-ia-gere-ton-niveau-1-quand-tu-es-seul-ou-presque
2) ADV (devis, commandes, factures, relances)
Ce qui s’automatise bien :
- Extraction des données d’un email client et pré-remplissage d’un devis.
- Vérifications simples (SIRET présent, adresse, référence commande).
- Relance douce “brouillon” + planification.
- Création de tâches internes (manque pièce, validation stock, délai).
Ce qui doit rester assisté :
- Remises hors barème, exceptions de paiement.
- Changement de RIB, coordonnées bancaires, virement.
- Envoi de facture si la donnée source n’est pas béton.
Point dirigeant : ADV = cash. Donc validation humaine obligatoire sur tout ce qui modifie un montant, une condition, une échéance.
3) Reporting (hebdo, mensuel, board)
Ce qui s’automatise bien :
- Collecte des chiffres depuis sources identifiées (fichiers, exports, tableaux).
- Consolidation, détection d’écarts, commentaires “premier jet”.
- Rédaction d’un résumé dirigeant (3 points, 3 risques, 3 actions).
Ce qui doit rester assisté :
- Interprétation finale (causalité) et décisions.
- Chiffres publiés externes (banque, investisseurs, partenaires) sans contrôle.
Garde-fou qualité : tu imposes des sources traçables et tu testes sur 2 cycles de reporting avant de laisser “agir”.
Checklist 30 minutes : ton plan de déploiement Copilot Autopilot sans te cramer
- 1 processus choisi (support OU ADV OU reporting).
- Niveau d’autonomie décidé (assisté ou semi-autonome au départ).
- Identité et droits minimum (lecture/écriture/envoi) validés.
- Logs et revue définis (qui regarde, quand, combien de temps).
- Points de validation humaine écrits comme des règles.
- Budget usage-based plafonné + alertes.
- Critères d’arrêt rédigés et acceptés.
Ce que tu fais cette semaine (sans projet à rallonge)
Tu ne “déploies pas Copilot Autopilot”. Tu lances un pilote gouverné.
- Jour 1 : tu choisis 1 processus et tu écris le périmètre (Décision 1) + le niveau d’autonomie (Décision 2).
- Jour 2 : tu fais le ménage des accès (Décision 3) et tu nommes owner/admin/auteurs (Décision 4).
- Jour 3 : tu actives traçabilité et tu définis validation humaine + tests qualité (Décisions 5, 6, 7).
- Jour 4 : tu fixes plafond et alertes usage-based (Décision 8).
- Jour 5 : tu écris les critères d’arrêt et tu lances sur un périmètre réduit (Décision 9).
Tu veux automatiser sans fuite de données et sans explosion de facture. Ce n’est pas une question d’outil. C’est une question de décisions. Maintenant tu as les 9.
