Terminez d'abord "Leçon 2 : Contrôler la sortie du modèle avec des invites structurées" pour débloquer cette leçon.Aller à la leçon précédente

Des Prompts uniques aux Flux de travail d’Agent

Un seul prompt demande au modèle une chose et obtient une réponse unique. Un flux de travail d’agent décompose un objectif complexe en plusieurs étapes : l’agent planifie, appelle un outil, lit le résultat, décide de la prochaine action et boucle jusqu’à ce que le travail soit terminé. Dans le développement d’applications web, cela signifie qu’une fonctionnalité IA peut récupérer des données, les transformer, les valider et répondre à l’utilisateur — le tout sans qu’un humain n’écrive chaque étape à la main.

Le passage se fait de « demander et répondre » à « décider et agir ». Au lieu d’un seul prompt soigneusement conçu, vous concevez une boucle : penser, agir, observer, répéter.

Éléments fondamentaux d’un flux de travail d’agent

Chaque flux de travail d’agent, quelle que soit sa complexité, est construit à partir des quatre éléments suivants.

Tout d’abord, un prompt système qui définit le rôle de l’agent, les outils à sa disposition et les règles sur le moment d’arrêter. Deuxièmement, une liste d’outils que l’agent peut appeler — des fonctions telles que `fetch_user_data`, `send_email` ou `query_database`. Troisièmement, un objet mémoire ou état qui porte l’information entre les étapes afin que l’agent n’oublie pas ce qu’il a déjà appris. Quatrièmement, une boucle de contrôle qui alimente la sortie de l’agent en entrée jusqu’à ce qu’elle indique l’achèvement.

Voici un motif minimal en TypeScript montrant la boucle :

typescript
async function runAgent(goal: string) {
let state = { goal, steps: [], done: false };
while (!state.done) {
const decision = await llm.decide(state);
if (decision.action === "finish") {
state.done = true;
} else {
const result = await callTool(decision.action, decision.input);
state.steps.push({ decision, result });
}
}
return state.steps;
}

L’agent voit `state`, décide quoi faire, le workflow exécute l’outil, et le résultat revient dans `state` pour le tour suivant.

organigramme montrant la boucle de l’agent : l’agent décide, l’outil s’exécute, le résultat est réinjecté dans l’état de l’agent, puis la boucle continue jusqu’à la fin

Gestion d'État et Conditions d'Arrêt

L'État est ce qui empêche l'agent d'être un poisson rouge. À chaque tour, l'agent doit voir : l'objectif d'origine, l'historique des actions passées et leurs résultats, et toute contrainte (comme « ne pas dépenser plus de 5 étapes » ou « arrêter si l'API renvoie une erreur »).

Les conditions d'arrêt comptent autant que les conditions de départ. Sans elles, un agent peut boucler indéfiniment ou épuiser votre budget API. Les motifs courants incluent : l'agent émet une action spéciale `finish`, une limite d'étapes est atteinte, une erreur se produit et le flux échoue, ou une vérification de validation confirme que l'objectif est atteint. Choisissez au moins une limite stricte (comme le nombre maximum d'étapes) comme filet de sécurité même si l'agent a un signal d'arrêt « naturel ».

Chaînage des Appels vs Appels en Parallel

Toutes les tâches multi-étapes n'ont pas besoin d'une boucle. Parfois, le chaînage suffit : la sortie de l'appel A devient l'entrée de l'appel B, sans prise de décision entre les deux. C'est plus rapide, moins coûteux et plus prévisible.

Utilisez une boucle uniquement lorsque l'étape suivante dépend de ce que l'étape précédente a retourné. Si vous résumez un avis utilisateur, puis le traduisez, puis l'envoyez par e-mail — c'est une chaîne. Si vous effectuez la recherche dans trois bases de données et fusionnez les résultats — c'est du parallélisme. Si vous recherchez dans une base de données, vérifiez si le résultat est vide, puis décidez s'il faut rechercher une autre source — c'est une boucle.

diagramme de comparaison côte à côte d'une chaîne linéaire (A à B à C) versus une boucle avec une branche de décision

Exemple pratique : Agent de support technique

Imaginez un flux de travail qui gère les tickets de support entrants. L'agent lit le ticket, le classe, vérifie le compte de l'utilisateur, et rédige soit une réponse, soit transmet à un humain.

typescript
async function handleTicket(ticketId: string) {
const ticket = await fetchTicket(ticketId);
const classification = await llm.classify(ticket.body);
if (classification.category === "billing") {
const account = await fetchAccount(ticket.userId);
const draft = await llm.draftReply(ticket, account);
await sendReply(ticket.userId, draft);
return { status: "replied", draft };
}
await escalateToHuman(ticketId, classification);
return { status: "escalated" };
}

Ce mélange de chaînage (classer puis rédiger) avec une décision de branchement. L'agent ne « pense » pas librement — il suit un script qui utilise le LLM à des points de décision spécifiques. C'est généralement le bon équilibre pour la production : flux déterministe, appels intelligents.

Erreurs courantes et comment les éviter

Donner à l'agent trop de liberté trop tôt. Commencez par un flux fixe qui appelle le LLM à des points de décision connus. N'ajoutez une boucle en libre accès que lorsque vous avez réellement besoin d'un comportement dynamique.

Oublier de consigner l'état. À chaque étape, chaque appel d'outil, chaque résultat — consignez-le. Quand quelque chose casse à 2 heures du matin, le journal est la seule façon de voir ce à quoi l'agent pensait.

Pas de logique de retry ou de fallback. Les outils échouent. Les API expirent. Implémentez des retries avec backoff, et prévoyez toujours un chemin de repli — même s'il s'agit juste de « envoyer le ticket à un humain ».

Laisser l'état s'enrichir sans limite. À chaque tour, l'agent voit l'historique complet. Après 20 étapes, cet historique devient volumineux et coûteux. Résumez ou tronquez les anciennes étapes lorsque la conversation devient longue.

Tổng kết

Un flux de travail d'agent est une boucle : le modèle décide, un outil s'exécute, le résultat met à jour l'état, et le cycle se répète jusqu'à ce qu'une condition d'arrêt se déclenche. L'état porte le contexte entre les étapes, et vous avez toujours besoin à la fois d'un signal d'arrêt naturel et d'une limite stricte. Commencez par l'enchaînement pour des pipelines prévisibles, et visez une boucle d'agent complète uniquement lorsque l'étape suivante dépend véritablement du résultat précédent. Enregistrez tout, réessayez les échecs et tronquez l'état à mesure qu'il se développe.

Entraînement

Point de contrôle de la leçon

Révisez la leçon et recevez des conseils sur votre travail.

0/1
Répondu · 0/1