“Un agent, c'est un stagiaire avec une liste de tâches et un téléphone. Utile pour les courses ; dangereux avec votre carte de crédit.”
Un agent n'est qu'une boucle
Il n'y a pas de magie. Un agent, c'est : un prompt système, un ensemble d'outils, et une boucle qui exécute le modèle, exécute l'outil qu'il appelle, retourne le résultat, et répète jusqu'à ce que le modèle produise une réponse finale ou atteigne une limite d'étapes. C'est toute l'idée. Tout le reste est de la discipline d'ingénierie autour de cette boucle.
messages = [system_prompt, user_message]
for step in range(MAX_STEPS):
response = model.call(messages, tools=TOOLS)
if response.is_final_answer:
return response.text
result = run_tool(response.tool_call) # your code, with all the guards
messages += [response, result]
raise StepLimitExceeded() # never loop forever
Pourquoi les agents tombent : l'erreur composée
La raison pour laquelle les longues exécutions d'agents échouent n'est pas que le modèle est stupide. C'est de l'arithmétique. Si chaque étape est fiable à 95 %, une tâche de 10 étapes réussit 0,95^10 ≈ 60 % du temps. Une tâche de 20 étapes : 36 %. L'erreur se compose de façon multiplicative, et il n'existe aucun prompt qui abolit la multiplication.
L'état honnête des agents : excellent pour des tâches bien délimitées de quelques étapes (« triez ce billet avec ces outils », « réconciliez ces deux enregistrements »), peu fiable pour des objectifs ouverts et à long horizon. La portée est le levier.
Comment en construire un qui fonctionne
Tout agent de production fiable fait la même poignée de choses. Rien d'exotique ; tout est de la discipline.
- Portée étroite — un seul travail, un petit ensemble d'outils, une définition claire de la fin. Plus la portée est étroite, plus l'évaluation est traçable.
- Plafond d'étapes strict — la boucle doit toujours se terminer. Un agent sans plafond est une facture sans plafond.
- Outils idempotents — chaque outil sûr à réessayer, parce que l'agent réessaiera.
- Humain dans la boucle pour les actions à enjeux élevés — proposez, n'exécutez pas, quand l'action est irréversible.
- Journalisez tout — chaque prompt, réponse, appel d'outil et résultat. Vous en aurez besoin dans la semaine.
Et préférez la structure à l'autonomie. Un flux de travail fixe avec un modèle à chaque point de décision est plus fiable qu'un agent pleinement autonome qui décide son propre plan — et bien plus facile à évaluer. Recourez à l'autonomie ouverte seulement quand la tâche l'exige vraiment, ce qui est plus rare que les démos ne le suggèrent.
Les systèmes multi-agents : prématurés la plupart du temps
Il est tentant de construire une équipe d'agents spécialisés qui se parlent. Parfois c'est le bon design. Habituellement, cela multiplie le problème d'erreur composée — maintenant vous avez plusieurs boucles fragiles qui se coordonnent — tout en rendant le système bien plus difficile à déboguer et à évaluer. Faites d'abord fonctionner un seul agent. Ajoutez des agents seulement quand vous pouvez pointer la limite précise qu'un seul a atteinte.
En une ligne chacun
- Un agent est un modèle dans une boucle avec des outils et un plafond d'étapes. Il n'y a pas de magie — seulement de l'ingénierie autour de la boucle.
- Les agents tombent parce que l'erreur se compose : 95 % par étape, c'est ~60 % sur 10 étapes. La multiplication se fiche de votre prompt.
- Construisez-les étroits : un seul travail, petit ensemble d'outils, plafond d'étapes strict, outils idempotents, portes humaines, journalisation complète.
- Préférez les flux de travail à l'autonomie et un seul agent à plusieurs — ajoutez de la complexité seulement contre une limite que vous avez réellement atteinte.
Où aller ensuite