Exemple d'agent IA : un trieur d'emails monté en six étapes

Un agent IA, c'est un modèle qui reçoit un objectif, choisit les outils à appeler, agit, lit le résultat et recommence jusqu'à ce que la tâche soit finie. L'exemple le plus utile quand tu travailles seul : un agent qui lit tes emails entrants, les classe, prépare la réponse et ne l'envoie que là où tu l'as autorisé. Voici comment le monter en six étapes, avec la décision qui compte à chacune.

Les listes de « 10 exemples d'agents IA » décrivent des catégories, jamais un agent entier avec ses outils, ses limites et ce qu'il n'a pas le droit de faire. Le trieur d'emails contient pourtant les quatre pièces de n'importe quel agent : une perception (lire la boîte), une décision (classer, choisir une action), des outils (chercher, rédiger, envoyer) et une mémoire (ce qui est déjà traité).

Étape 1 : choisir une boucle que tu sais juger en trente secondes

L'objectif est étroit : chaque email entrant reçoit une catégorie (prospect, client, facture, bruit), un résumé d'une ligne, et un brouillon de réponse quand une réponse est attendue.

La décision clé est de prendre une tâche dont tu peux juger la sortie d'un coup d'œil. Tu sais en trois secondes si un email est un prospect ou une facture. La première tâche d'un agent doit être vérifiable.

L'erreur à éviter est de commencer par la tâche la plus pénible au lieu de la plus répétitive. La plus pénible demande le plus de jugement, donc l'agent s'y trompera le plus, là où tu le verras le moins.

Étape 2 : écrire le contrat de sortie avant le prompt

Avant la moindre instruction, écris ce que l'agent doit produire pour chaque email. Pas de prose, mais une structure fixe, avec des champs.

{
  "categorie": "prospect | client | facture | bruit",
  "resume": "une phrase",
  "action": "brouillon | classer | ignorer | escalader",
  "confiance": 0.0,
  "brouillon": "texte de la réponse, ou null"
}

La décision clé est de rendre toute sortie vérifiable par un script. Un champ manquant, une catégorie hors liste, un brouillon sur un email classé « bruit » : la sortie est refusée avant d'avoir le moindre effet. Dès que le format est strict, le prompt raccourcit, parce que la moitié des règles deviennent des champs obligatoires.

L'erreur à éviter est de laisser l'agent répondre librement parce que c'est plus naturel. Une réponse naturelle ne se teste pas. Le champ confiance n'est pas une probabilité exacte, c'est un tri : en dessous d'un seuil, l'email revient vers toi.

“

Le vrai livrable de la première semaine n'est pas l'agent, c'est le fichier de vingt emails annotés qui sert de prompt, de test et de seuil.

”

Étape 3 : donner les outils un par un, l'action en dernier

Il faut quatre outils : lire les nouveaux emails, chercher un contact dans ton fichier clients, créer un brouillon, envoyer. Seul le quatrième a un effet sur le monde extérieur.

La décision clé est de séparer les outils qui lisent de celui qui agit, et de ne brancher celui-ci qu'après l'étape 5. La première semaine, l'agent n'a même pas l'outil « envoyer ». Un agent qui ne peut pas envoyer ne peut pas envoyer la mauvaise chose.

L'outil de recherche client pèse plus que le choix du modèle : un email de Julie n'est un prospect que si Julie n'est pas déjà cliente, et cette information n'existe que dans ta fiche contact. La question de savoir qui détient l'information dans la fiche contact se pose donc dès la conception de l'agent. L'agent doit aussi avoir sa propre adresse plutôt que la tienne : une boîte créée par API, comme le propose AgentMail, lui donne un accès révocable sans toucher à ton compte.

L'erreur à éviter est de donner tous les accès le premier jour parce que de toute façon tu surveilles. Tu surveilleras trois jours.

Étape 4 : instruire par l'exemple, pas par le règlement

Le prompt contient trois choses : le rôle de l'agent en deux phrases, le contrat de sortie de l'étape 2, et des emails réels annotés.

Prends dix emails que tu as reçus, anonymise-les, et écris à côté de chacun la sortie exacte que tu attends : la catégorie, l'action, et pour deux ou trois d'entre eux le brouillon que tu aurais envoyé, dans ton ton. Ces exemples fixent la frontière entre « prospect » et « bruit » mieux que n'importe quelle définition, et ils fixent ton style de réponse.

La décision clé est de privilégier les exemples et le format imposé aux règles abstraites. C'est la conclusion à laquelle j'arrivais en comparant quatre façons d'écrire des prompts ChatGPT : les deux méthodes qui tiennent dans le temps sont celles-là.

L'erreur à éviter est d'écrire trois pages de règles (sois professionnel, ne réponds jamais aux relances commerciales, si le client semble mécontent alors...). Une règle abstraite se contourne dès le premier cas ambigu.

Étape 5 : vingt emails réels, à la main, avant tout automatisme

Fais tourner l'agent toi-même sur vingt emails réels que tu n'as pas utilisés à l'étape 4. Pour chacun, compare la sortie de l'agent à ce que tu aurais fait, puis compte les accords par catégorie.

La décision clé est de fixer un seuil d'autonomie par catégorie, pas pour l'agent entier. Sur les factures, tu constateras peut-être vingt accords sur vingt : la catégorie peut être classée seule. Sur les prospects, il y aura des désaccords sur le ton du brouillon : cette catégorie reste en relecture. Un agent n'est jamais fiable en bloc, seulement sur certaines classes de cas, et le tableau te dit lesquelles.

Ce tableau est le vrai livrable de la première semaine. Le même fichier de vingt emails annotés sert trois fois : il nourrit le prompt en exemples, il sert de test quand tu modifies une instruction, et il fixe le seuil d'autonomie par catégorie.

L'erreur à éviter est de juger sur trois emails du même type, tous réussis. Trois réussites ne disent rien. Vingt emails, avec un cas ambigu par catégorie, disent quelque chose.

Étape 6 : lâcher par catégorie, garder une mémoire

Seulement maintenant, tu branches l'outil « envoyer », et seulement sur la catégorie où le taux d'accord était total.

La décision clé est de donner à l'agent une mémoire de ce qu'il a déjà traité. Une ligne par email, écrite avant l'action, marquée « fait » après. Sans elle, l'agent relancé après une coupure reclasse et renvoie.

Le passage du brouillon à l'envoi automatique est le moment où tu sors de la boucle, et ce seuil compte plus que le choix du modèle : je détaille dans le seuil où un agent IA gratuit casse ce qui lâche à la première exécution que personne ne regarde.

L'erreur à éviter est d'ouvrir l'envoi automatique partout parce que ça a bien marché. Ce qui a bien marché, c'est une catégorie. Les autres ont un taux d'accord que tu connais.

Le lundi suivant, tu as un agent qui classe tout, qui répond seul aux factures et qui te laisse des brouillons pour les prospects. La seule question encore ouverte est la bonne : quelle est la prochaine catégorie dont le taux d'accord justifie de lâcher la relecture ?

FAQ

Quels autres exemples d'agents IA suivent le même schéma ? Toute boucle d'entrées répétitives avec une sortie vérifiable : répondre aux commentaires et aux DM sur les réseaux sociaux, préparer des devis à partir d'une demande. Les commentaires et les DM, c'est ce que fait ReadyToPost, avec la même règle : l'agent prépare, tu valides.

Quelle différence entre un agent IA et une automatisation classique ? Une automatisation suit un chemin fixé à l'avance : si A, alors B. Un agent reçoit un objectif et choisit lui-même quels outils appeler, dans quel ordre, selon ce qu'il lit. Utile quand les entrées varient trop pour écrire tous les cas, risqué pour la même raison.

Faut-il coder pour monter cet exemple ? Pas forcément. Un automatiseur visuel avec un nœud « modèle » et des nœuds d'outils suffit pour les six étapes. Le code devient nécessaire pour un validateur strict sur la sortie ou une mémoire propre, vers l'étape 5.

Combien de temps pour arriver à l'étape 6 ? Une semaine à temps partiel est réaliste pour une personne seule, à condition de ne pas sauter l'étape 5. C'est celle qui produit le seul chiffre utile : le taux d'accord par catégorie.