Flux de travail des agents et tâches en plusieurs étapes

Gains :

• Appliquer l'échelle croissante de complexité de la solution la plus simple à l'agent
• Distinguer les modèles de flux de travail enchaînés, de routage et parallèles
• Diviser une tâche en plusieurs étapes en un cycle de planification-exécution-vérification

Nous avons établi le cycle simple à véhicule unique dans l’unité précédente. Le vrai travail nécessite souvent plusieurs étapes, plusieurs outils et parfois des décisions ramifiées : "Trouver les commandes en retard ce mois-ci, rédiger un e-mail d'excuses aux clients, résumer pour un responsable." Dans cette unité, nous abordons les modèles d'organisation de tâches en plusieurs étapes, lorsque vous avez besoin d'un véritable agent, ainsi que le cycle planification-exécution-vérification. Le grand principe : la complexité autant que le besoin.

Passez de la solution la plus simple à l'agent

Toutes les tâches ne méritent pas la solution la plus complexe. Montez pas à pas sur l’échelle de complexité et arrêtez-vous à la solution adéquate la plus simple :

1. Appel unique : si la tâche est résolue par un seul appel de modèle (résumer, classer), arrêtez-vous ici.
2. Appel unique avec RAG : Si des informations sont requises, ajoutez la récupération et à nouveau un appel unique.
3. Workflow fixe : si les étapes sont connues à l’avance, séquencez-les manuellement (flux de code). Le modèle effectue un sous-travail à chaque étape, mais vous déterminez l'ordre.
4. Agent piloté par un modèle : si les étapes ne peuvent pas être connues à l'avance, le modèle décide quel agent appeler et quand. L’option la plus puissante mais la plus coûteuse et la plus risquée.

La différence entre Workflow et agent est cruciale : dans Workflow, vous écrivez le flux de contrôle (prévisible, testable, bon marché). Vous donnez le contrôle de l'agenda au modèle (flexible mais imprévisible). La plupart du travail en entreprise est en fait un flux de travail ; les vrais agents sont relativement peu nombreux.

Astuce : « Puis-je écrire les étapes de cette tâche à l'avance ? » demander. Si vous pouvez l'écrire, créez un flux de travail : moins cher, plus sûr et plus testable. Cependant, si les étapes varient en fonction de l’entrée et ne peuvent être prédites, un agent est requis.

Trois modèles de flux de travail de base

Chaînage d'invites : la sortie d'une étape est l'entrée de la suivante. "Générer un brouillon → modifier → formater." Chaque étape est simple et ciblée ; facile à déboguer.

Routage : Vous classez d'abord la demande entrante et l'envoyez à l'expert approprié. « Cette question est-elle technique, de facturation ou de remboursement ? » → rediriger vers le sous-flux correct. Chaque chemin est optimisé avec sa propre invite et ses propres outils.

Parallélisation : exécuter des tâches indépendantes simultanément et combiner les résultats. "Résumez 5 documents séparément, puis combinez-les." Non seulement c’est rapide, mais chaque pièce reçoit toute l’attention.

modèle

quand

exemple

enchaîné

Les étapes sont séquentielles et dépendantes

Brouillon → modifier → formater

rediriger

Traitement différent selon le type d'entrée

Classification des demandes d'assistance

parallèle

Sous-travaux indépendants

Résumer plusieurs documents séparément

Agent (boucle)

Les étapes ne peuvent pas être prédites à l’avance

Recherche/réparation ouverte

# Modèle de routage (conceptuel)type = pattern.classify(request) # "return" | "techniques" | "facture"if tour == "retour": réponse = retour_flow(requête)elif tur == "technique": réponse = flux_technique(demande)else: réponse = facture_flow(demande)

Cycle Planification-Exécution-Vérification

Un modèle puissant chez les agents réels : planifiez le modèle, puis exécutez, puis vérifiez. Le modèle divise la tâche complexe en sous-étapes, exécute chaque étape avec des outils et demande enfin « ai-je atteint l'objectif ? il vérifie. L’étape de vérification détecte les erreurs avec un regard distinct et nouveau (« ce résultat répond-il à la tâche ? »).

# Plan-execute-verify (conceptuel)plan = model.uret("Divisez cette tâche en étapes : " + tâche)pour l'étape du plan : result = agent_loop(step) # exécuter avec toolscheck = model.uret("Cette sortie répond-elle à la tâche ? Dites-moi s'il manque quelque chose : " + tâche + résultats)if check.missing : # cycle de correction ...

Deux bonnes pratiques pour les tâches longues : imposer une condition d'arrêt (nombre maximum d'étapes — évite les boucles infinies) et un suivi de progression (demander à l'agent d'écrire ce qu'il fait pour ne pas se laisser distraire). L'agent, qui n'a pas de limite de pas, peut tourner indéfiniment s'il reste bloqué et le coût va exploser.

Conception faible/forte

Faible (mettre tout sur un seul agent géant) :

Dites « faites cette chose complexe » et publiez-la avec des outils illimités.# Résultat : comportement imprévisible, risque de boucles infinies, coût élevé,# impossible à déboguer.

Puissant (flux en premier, agent uniquement là où c'est nécessaire, limité) :

Divisez d’abord le travail en étapes fixes (routage + chaînage). Utilisez l'agent uniquement dans les sous-tâches dont les étapes sont inconnues ; Ajoutez une limite de pas, un suivi des progrès et un cycle de vérification.

Trois mini-étuis

Cas 1 — Workflow au lieu d'un agent. Une équipe a mis en place la tâche « processus de demande de support » avec un agent libre ; Parfois, l’agent faisait 15 marches et empruntait le mauvais chemin. Les étapes étaient essentiellement fixes (classer → récupérer les informations pertinentes → rédiger un brouillon → soumettre pour approbation). Lorsque nous sommes passés au workflow routage + chaînage, la cohérence est passée de 58 % à 96 % et le coût a été divisé par deux.

Cas 2 — Gain parallèle. Une équipe juridique résumait 20 contrats un par un ; Cela a pris 4 minutes au total. Lorsque nous sommes passés à un modèle parallèle (tous en même temps, puis combinés), le temps a été réduit à 25 secondes et la qualité a augmenté à mesure que chaque résumé recevait toute l'attention.

Cas 3 — Il n'y avait aucune condition d'arrêt. Un agent d'enquête n'arrêtait pas d'appeler les deux mêmes outils, cherchant des informations qu'il ne trouvait pas ; accumulé des coûts importants du jour au lendemain. Lorsque la limite maximale de 8 étapes et la règle « Si vous ne le trouvez pas en 3 essais, dites que je ne sais pas » ont été ajoutées, le coût a été maîtrisé et des réponses honnêtes « Je n'ai pas pu le trouver » sont venues.

Erreurs courantes

• Tout déléguer à l'agent : le flux de travail est moins cher, plus sûr et testable si les étapes sont connues.
• Mélanger le workflow avec l'agent : est-ce que vous ou le modèle prenez le contrôle ? Ne concevez pas sans que cela soit clair.
• Ne pas définir de condition d'arrêt : l'agent entre dans une boucle infinie et accumule des coûts.
• Pas de suivi des progrès : lors d'une longue mission, l'agent est distrait et refait le même travail.
• Ignorer le cycle de vérification : un résultat incorrect mais plausible est fourni sans contrôle.

Attention : plus l'agent est libre, plus le rayon d'explosion est grand. La flexibilité n’est pas gratuite ; chaque liberté supplémentaire ajoute de l’imprévisibilité et du risque. Choisissez la solution adéquate la plus étroite.

En résumé

• Dans la complexité, le principe du « selon les besoins » s'applique : appel unique → RAG → workflow → agent uniquement si c'est vraiment nécessaire.
• Dans Workflow, vous écrivez le flux de contrôle (prévisible) ; Vous laissez l'agenda au modèle (flexible mais risqué).
• Trois modèles de base : chaînage (dépendant séquentiellement), routage (distribué par type), parallèle (tâches indépendantes).
• Les vrais agents utilisent le cycle planifier-exécuter-vérifier, les conditions d’arrêt et le suivi des progrès.
• À mesure que la flexibilité augmente, l’imprévisibilité et les coûts augmentent ; Choisissez la solution adéquate la plus étroite.

Tâche de candidature

Choisissez une tâche en plusieurs étapes de votre propre entreprise (par exemple « préparer et distribuer un rapport mensuel »). (1) Pouvez-vous écrire les étapes de cette tâche à l’avance ? Si vous pouvez l'écrire, concevez-le comme un workflow (quel modèle : chaînage/routage/parallèle ?) ; Si vous ne pouvez pas écrire, expliquez pourquoi un agent est nécessaire. (2) Dessinez le motif que vous avez choisi avec un diagramme en forme de boîte et de flèche. (3) S'il s'agit d'une agence : écrivez comment vous allez configurer la condition d'arrêt, le suivi des progrès et le cycle de vérification. (4) Énumérez 3 risques liés à l’exécution de la même tâche avec un « seul agent de développement ».

liste de contrôle

• [ ] Je peux choisir le bon niveau sur l'échelle « complexité selon les besoins ».
• [ ] Je peux distinguer la différence de contrôle entre Workflow et agent.
• [ ] Je peux mapper les modèles de chaînage, de routage et de parallèle aux tâches appropriées.
• [ ] Je peux configurer le cycle planifier-exécuter-vérifier, les conditions d'arrêt et le suivi des progrès dans les agents.
• [ ] Je garde à l'esprit qu'une trop grande flexibilité entraîne de l'imprévisibilité et des coûts.