Planification + garde-fous de boucle
Un agent qui peut agir peut aussi agir indéfiniment. La première façon dont un vrai agent brûle de l'argent et réveille un ingénieur d'astreinte, c'est une boucle sans freins : il continue d'appeler le même outil, d'obtenir la même observation, sans jamais décider qu'il a fini. Cette leçon ajoute les deux éléments qui rendent un agent sûr à exécuter : un petit planificateur qui découpe un objectif en sous-tâches ordonnées, et un garde-fou de boucle qui arrête l'agent avant qu'il ne s'emballe.
D'abord, la planification. decompose(goal) transforme un objectif d'une ligne en une liste numérotée de sous-tâches. On la garde déterministe et fondée sur des règles (en production c'est le LLM qui s'en charge, mais c'est la forme qui compte) : découpe l'objectif sur le mot "then", nettoie chaque morceau, et numérote-les à partir de 1.
decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]Maintenant, le garde-fou. run_with_guard(policy, state, max_steps) pilote une politique étape par étape, mais elle refuse de s'emballer. Une politique est ici une fonction policy(state) -> action (une chaîne qui nomme l'action qu'elle veut faire) ; appliquer une action revient simplement à l'ajouter à une liste d'historique. Le garde-fou s'arrête pour l'une de trois raisons et indique laquelle :
- terminé : la politique renvoie l'action
"done"-> arrêt avec la raison"done". - aucun progrès : la politique renvoie la même action deux fois de suite -> arrêt avec la raison
"repeat". C'est le signal classique d'une boucle coincée : l'agent n'apprend rien de ses observations. - budget : elle atteint
max_stepssans avoir fini -> arrêt avec la raison"max_steps".
def run_with_guard(policy, state, max_steps):
history = []
for _ in range(max_steps):
action = policy(state)
if action == "done":
return {"history": history, "reason": "done"}
if history and action == history[-1]:
return {"history": history, "reason": "repeat"}
history.append(action)
# let the policy advance its own state here
...
return {"history": history, "reason": "max_steps"}Renvoie un dict {"history": [...], "reason": ...}. C'est la vérification "repeat" qui te sauve : une politique boguée ou perdue qui émet "search" à l'infini est arrêtée à la deuxième action identique, avec une raison que tu peux journaliser et sur laquelle tu peux déclencher une alerte. Une politique bien élevée qui progresse puis dit "done" termine proprement dans son budget. Le correcteur vérifie qu'une politique qui boucle s'arrête avec "repeat", qu'une politique qui s'emballe atteint "max_steps", et qu'une bonne politique termine avec "done", ainsi que la bonne numérotation de decompose. Appuie sur Run pour voir les trois issues.
Écris decompose(goal) : découpe goal sur " then ", nettoie chaque partie, et renvoie-les sous la forme "1. part", "2. part", ... Puis écris run_with_guard(policy, state, max_steps), où policy(state) renvoie une chaîne d'action. Pilote la politique jusqu'à max_steps fois et renvoie {"history": [...], "reason": ...} : arrête-toi avec la raison "done" quand l'action est "done" ; avec la raison "repeat" quand une action est égale à celle d'immédiatement avant (aucun progrès) ; avec la raison "max_steps" si le budget est épuisé. Ajoute chaque action acceptée à history.
Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon
Cet exercice s'ouvre bientôt
Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.
Ce navigateur bloque les cookies pour learn.floati.life, donc les leçons que tu as terminées ici ne peuvent pas s'ouvrir dans l'ordre. Autorise les cookies pour ce site et recharge la page.