Créer un workflow agentique : le tutoriel complet, de l'idée à la production

« Agentique » est le mot le plus usé de l'année, et le moins défini. Entre le script qui tourne la nuit et l'agent autonome à qui l'on confie les clés, il existe un territoire intermédiaire, pragmatique, où se joue l'essentiel de la valeur : le workflow agentique — un enchaînement d'étapes dont certaines délèguent à un modèle de langage le jugement, sans lui déléguer la décision finale. Ce tutoriel vous prend par la main pour en construire un, de la première question — est-ce que ma tâche en vaut la peine — jusqu'à la mise en production et la mesure des résultats. Aucun framework à la mode requis : un modèle, des outils, des garde-fous, du bon sens.

Un workflow agentique, concrètement, c'est quoi ?

Prenons une définition opérable, pas une définition de conférence. Un workflow agentique est un processus automatisé qui enchaîne des étapes déterministes et des étapes de jugement. Les étapes déterministes — récupérer des données, filtrer, formater, écrire en base — restent du code classique, testable et prévisible. Les étapes de jugement — résumer un document, classer une requête, rédiger une réponse, décider d'un routage — sont confiées à un modèle de langage, avec un périmètre délimité et une sortie contrôlée. Le mot « agentique » ne veut pas dire « ça décide tout seul » : il veut dire que le jugement est injecté là où les règles échouent, et nulle part ailleurs.

Cette nuance vous évitera le piège numéro un des projets d'automatisation : tout confier au modèle. Un agent qui reçoit une mission vague, un navigateur et un terminal produit des démonstrations spectaculaires et des incidents de production tout aussi spectaculaires. La littérature d'ingénierie converge sur ce point depuis plusieurs cycles — la référence sur la construction d'agents effectifs le pose en principe fondateur : commencer simple, n'ajouter d'autonomie que là où la valeur le justifie. Un workflow agentique bien conçu applique exactement ce principe.

La différence avec les approches voisines se voit mieux en tableau qu'en discours — nous y reviendrons pour l'orchestration. Retenez pour l'instant le test au feutre : si votre tâche se décrit entièrement par des règles, c'est un script. Si elle exige du jugement à chaque étape avec un but mouvant, c'est un agent autonome — un autre métier. Entre les deux, quand le jugement intervient à des endroits identifiés d'un processus stable, c'est un workflow agentique, et c'est le terrain de ce tutoriel.

Étape zéro : vérifier que votre tâche mérite ce traitement

La moitié des automatisations échouent avant la première ligne de code, sur un mauvais diagnostic de la tâche. Avant d'ouvrir l'éditeur, passez votre candidat au crible de ces critères — c'est un quart d'heure qui épargne des semaines :

• La tâche se répète — quotidiennement ou plusieurs fois par semaine ; une tâche mensuelle à faible enjeu se traite à la main ;
• Elle suit un déroulé stable — les mêmes étapes dans le même ordre à chaque occurrence, même si le contenu varie ;
• Au moins une étape exige du jugement — lire, comprendre, résumer, classer, reformuler : ce qu'aucune règle ne couvre proprement ;
• La sortie est vérifiable — un humain peut contrôler le résultat en quelques secondes ; une sortie invérifiable est une bombe à retardement ;
• L'échec est supportable — le coût d'une exécution ratée, détectée et corrigée, reste inférieur au gain d'une exécution réussie.

Trois critères sur cinq : candidat sérieux. Moins de trois : retournez à la conception de la tâche, ou à la main-d'œuvre. Et méfiez-vous du cas limite séduisant : la tâche fréquente mais à sortie invérifiable — c'est elle qui produit les dérives silencieuses que l'on découvre trois mois trop tard, quand un client s'en plaint.

Nous avons documenté ce criblage en conditions réelles dans notre retour d'expérience sur un pipeline SEO construit avec Claude et Python sur PrestaShop : la partie la plus utile du travail n'a pas été d'écrire le code, mais de décider quelles étapes restaient déterministes et lesquelles méritaient le jugement du modèle.

L'anatomie : cinq briques à assembler avant d'écrire la première étape

Tout workflow agentique de production, quelle que soit la pile technique, repose sur les cinq mêmes briques. Les poser explicitement avant de coder est ce qui distingue un outil durable d'un prototype qui tombe en panne au premier imprévu.

Le déclencheur — ce qui démarre l'exécution : un horaire, un webhook, un email, un dépôt de fichier. Privilégiez le déclenchement à l'événement sur le minutage aveugle : réveiller un modèle à intervalle fixe pour rien brûle du budget et masque les vrais signaux. Le contexte — l'ensemble des données que le modèle voit à chaque étape de jugement : c'est la variable la plus déterminante de la qualité de sortie. Trop pauvre, le modèle hallucine ; trop riche, il se noie et le coût explose. Les outils — les actions que le modèle est autorisé à appeler : lire un fichier, requêter une base, appeler une API. Chaque outil porte un contrat précis, entrées et sorties. Les garde-fous — les limites dures : nombre maximal d'étapes, budget en tokens, validation humaine sur les actions sensibles, liste blanche d'actions. Le journal — la trace de chaque exécution : entrées, sorties, décisions, coûts. Sans journal, pas de débogage, pas d'audit, pas d'amélioration.

Ces cinq briques ne demandent aucune technologie exotique. Un script Python, le SDK d'un fournisseur de modèle, une base pour le journal, un planificateur pour le déclencheur : la pile minimale tient dans quatre dépendances. C'est un choix délibéré de ce tutoriel — la valeur est dans la conception, pas dans l'outillage.

Le tutoriel : un workflow de veille et synthèse, de zéro à la production

Construisons le candidat le plus universel : chaque matin, le workflow collecte les nouveaux contenus d'une liste de sources, les filtre selon vos critères, demande au modèle une synthèse structurée de ce qui compte, et dépose le résultat dans un canal que vous lisez déjà. C'est le « hello world » des workflows agentiques — assez simple pour tenir un après-midi, assez complet pour porter toutes les briques.

Pas un. Définissez le déclencheur et le contrat de sortie. Ici : chaque matin à heure fixe, et une sortie markdown à trois sections — à lire en priorité, à surveiller, ignoré pourquoi. Écrire le format de sortie avant d'écrire le code est le geste qui épargne le plus de reprises : le modèle remplira ce que vous aurez défini. Pas deux. Implémentez la collecte en code déterministe : récupération des flux, déduplication contre les exécutions précédentes, filtrage grossier par mots-clés. Rien de « agentique » ici, et c'est voulu — chaque octet de déterminisme que vous gardez est un octet dont vous n'avez pas à auditer le modèle. Pas trois. Introduisez la première étape de jugement : le modèle reçoit les titres et extraits, retourne pour chacun un classement et une raison, en format strict que votre code valide — structure JSON, champs obligatoires, valeurs dans une énumération. Si la sortie est invalide, une relance unique avec le message d'erreur, puis abandon journalisé : jamais de boucle infinie sur une étape de jugement.

Pas quatre. Ajoutez la synthèse : le modèle rédige les trois sections à partir des seuls éléments retenus — pas de la collection entière, le contexte se mérite. Pas cinq. Posez les garde-fous de production : budget maximal par exécution, coupure si une source répond mal trois jours de suite, alerte silencieuse vers votre canal plutôt qu'un échec bruyant, journal complet de chaque décision. Pas six. Exécutez à la main dix matins d'affilée, en corrigeant à chaque fois la seule chose qui a cloché. Au dixième matin sans correction nécessaire, vous avez un workflow de production — et l'intuition de ce qui mérite la deuxième automatisation.

Ce déroulé en six pas se transpose à presque tous les candidats : veille, tri de demandes entrantes, préparation de rapports, premiers filtres de support. La mécanique ne change pas — seuls le collecteur déterministe et le contrat de sortie changent. Nos résultats mesurés sur un pipeline SEO automatisé suivent exactement cette ossature, et c'est en la tenant à l'œil qu'on comprend où va réellement le temps d'entretien.

Les garde-fous qui séparent un jouet d'un outil

Un workflow agentique sans garde-fous n'est pas une automation, c'est un pari. Les défaillances observées en production se rangent dans quatre familles, toutes évitables par construction :

• La dérive de contexte — l'étape de jugement reçoit trop d'entrées hétérogènes et se met à tout mélanger ; le remède est le filtrage en amont, jamais la prière en aval ;
• La sortie hors contrat — le modèle improvise un format ; le remède est la validation structurelle systématique, avec relance unique puis abandon journalisé ;
• Le coût silencieux — une boucle d'étapes qui s'emballe sur un cas pathologique ; le remède est le budget plafonné par exécution, sans exception ;
• L'action irréfléchie — le workflow écrit, envoie ou supprime quelque chose sans contrôle ; le remède est la validation humaine sur toute action irréversible, sans exception non plus.

Ces deux derniers points ne sont pas négociables, et c'est la ligne que nous tenons sur nos propres systèmes : toute écriture externe — un envoi, une publication, une suppression — passe par une relecture humaine explicite. Le déterminisme des garde-fous ne s'achète pas avec du prompting, il s'assemble dans le code.

Un workflow agentique n'est pas fiable parce que le modèle est intelligent — il est fiable parce que sa conception suppose qu'il ne l'est pas toujours.

Ajoutez à cela une règle d'exploitation qui revient dans tous les retours d'expérience sérieux : ne réveillez pas un modèle sur minuterie pour des tâches qui n'exigent pas son intelligence à cet instant. Les jobs minutés portent du déterminisme ; le jugement se déclenche à la demande ou à l'événement. Votre facture et votre capacité de diagnostic vous remercieront.

Orchestration : les quatre patterns et quand les utiliser

Quand votre workflow grandit au-delà de la ligne droite, quatre patterns d'orchestration couvrent l'essentiel des besoins réels — et se combinent. Le tableau suivant dit lequel atteindre en premier :

La discipline est la même pour les quatre : le contrôle des flux — branchements, boucles, arrêts — vit dans votre code, où il est testable ; le modèle se concentre sur le jugement demandé, où il est irremplaçable. C'est cette séparation qui rend le tout auditable : quand quelque chose cloche, vous savez si c'est l'orchestration ou le jugement, et les deux ne se corrigent pas de la même main.

Mesurer, industrialiser, tenir dans le temps

Un workflow agentique en production est un actif qui s'entretient. Trois mesures suffisent à piloter les premiers mois : le taux d'exécutions complétées sans intervention — votre indicateur de fiabilité ; le coût par exécution réussie — budget modèle et temps d'entretien compris ; et le temps humain économisé net — ce que la tâche coûtait avant, moins ce que son contrôle coûte maintenant. Si le premier plonge, vos garde-fous crient. Si le deuxième grimpe, votre contexte dérive. Si le troisième est négatif, vous avez automatisé une corvée en une autre : c'est une information précieuse, pas un échec — elle désigne la prochaine cible.

Côté industrialisation, la sobriété paie : versionnez le workflow comme le reste du code, journalisez chaque décision avec ses entrées tronquées, testez les étapes déterministes comme n'importe quel code, et gardez pour les étapes de jugement des jeux d'essai figés — entrées réelles passées, sorties attendues — pour détecter les dérives de comportement quand vous changez de version de modèle. Ne courez pas après les orchestrateurs exotiques tant que vos quatre patterns ne suffisent plus à exprimer votre besoin : ils suffisent longtemps.

Reste la question du positionnement, car un workflow agentique n'est pas une fin : c'est une brique d'une organisation qui délègue mieux. Nous avons raconté comment cette brique s'inscrit dans une stratégie plus large — la bascule d'une équipe vers des pratiques qui mettent l'IA au cœur du déroulé quotidien — dans notre analyse sur l'écart d'adoption de l'IA-first entre la France et les États-Unis, et comment ces automatisations changent la fabrication même du contenu dans notre panorama de l'AIO appliquée à l'e-commerce. Le fil conducteur est le même que ce tutoriel : le jugement délégué gagne quand la décision reste tenue.