Comment un agent IA prend-il ses décisions ?

Un agent IA prend ses décisions en boucle : il observe la situation, écrit ce qu’il compte faire, choisit un outil, lit le résultat, puis recommence jusqu’à atteindre l’objectif ou une limite fixée. Chaque « décision » est en réalité une prédiction du modèle de langage, guidée par ses instructions, les outils mis à sa disposition et tout ce qu’il a déjà vu pendant la tâche.

Un modèle de langage ne décide pas comme vous

Au cœur d’un agent se trouve un grand modèle de langage. Seul, il ne fait qu’une chose : produire la suite la plus probable d’un texte. Il n’a ni volonté ni but propre.

Ce qui en fait un agent, c’est le programme qui l’entoure. Ce programme lui présente un objectif, une liste d’outils et l’historique de ce qui s’est passé, puis lui demande en substance : « Que fais-tu maintenant ? » Le modèle répond soit par un texte final, soit par une demande d’action. Le programme exécute l’action, ajoute le résultat à l’historique et repose la question.

Une « décision » d’agent, c’est donc le choix de la prochaine action parmi celles qui sont permises. Pour une présentation générale de ces systèmes, voyez notre guide agent IA : définition, fonctionnement et exemples.

La boucle de base : penser, agir, observer

Le schéma le plus répandu porte un nom : ReAct, pour Reasoning and Acting. Il a été décrit dans l’article « ReAct: Synergizing Reasoning and Acting in Language Models », déposé sur arXiv le 6 octobre 2022 par Shunyu Yao et ses coauteurs (Princeton et Google). L’idée : faire alterner le raisonnement et l’action, au lieu de les traiter séparément. Notre fiche sur le schéma ReAct en donne la mécanique détaillée.

À chaque tour, l’agent passe par trois temps :

1. Pensée : il écrit ce qu’il a compris et ce qu’il compte faire.
2. Action : il choisit un outil et ses paramètres.
3. Observation : il lit le résultat renvoyé par l’outil.

Prenons un exemple. Vous demandez : « Trouve un restaurant italien ouvert dimanche soir près de chez moi et réserve pour quatre à 20 h. »

Tour	Pensée de l’agent	Action	Observation
1	Il me faut l’adresse de l’utilisateur	Lire le profil	Adresse trouvée
2	Je cherche des restaurants italiens proches	Recherche web	Cinq adresses
3	Lesquels sont ouverts dimanche soir ?	Lire les pages des restaurants	Deux sont ouverts
4	Je vérifie la disponibilité à 20 h	Ouvrir le site de réservation	Une table libre
5	La réservation engage l’utilisateur	Demander confirmation	En attente de votre accord

Rien de magique : l’agent a simplement enchaîné cinq petites décisions, chacune appuyée sur l’observation précédente. Au tour 3, s’il avait mal lu un horaire, toute la suite aurait été faussée.

Planifier : découper l’objectif avant d’agir

Pour une tâche courte, l’agent peut avancer pas à pas. Pour une tâche longue, il gagne à faire un plan : c’est la décomposition de tâches. « Préparer un week-end à Lisbonne » devient : fixer le budget, chercher des vols, comparer trois hôtels, proposer un programme, tout résumer dans un tableau.

Deux approches coexistent :

• Le plan fixe, écrit à l’avance par le développeur. Prévisible et facile à tester, il convient aux tâches répétitives.
• Le plan dynamique, proposé par le modèle lui-même puis révisé selon ce qu’il découvre. Plus souple, il est aussi plus difficile à contrôler.

Un bon agent ne suit pas son plan aveuglément. Si le vol prévu est complet, il doit revenir en arrière et ajuster la suite. C’est ce qui distingue un agent d’une simple automatisation, une différence que nous développons dans IA agentique : ce que veut vraiment dire ce mot.

Appeler un outil : comment le choix se fait

Le moment clé d’une décision, c’est le choix de l’outil. Techniquement, il passe par l’appel d’outils, aussi appelé function calling.

Concrètement, le développeur décrit chaque outil au modèle : un nom, une phrase qui explique à quoi il sert, et la liste des paramètres attendus. Quand le modèle juge qu’un outil est utile, il ne répond pas par une phrase, mais par une demande structurée, par exemple chercher_vols(depart="Paris", arrivee="Lisbonne", date="2026-11-14"). Ce format est une sortie structurée que le programme peut lire sans ambiguïté.

Le modèle n’exécute jamais lui-même l’outil. C’est le programme qui le fait, puis lui renvoie le résultat. Cette séparation est précieuse : c’est là qu’on peut interdire une action, la journaliser ou la soumettre à votre validation.

La qualité des décisions dépend donc beaucoup de la qualité des descriptions. Un outil mal décrit sera mal utilisé, ou pas utilisé du tout. Des standards comme MCP permettent désormais de brancher des outils de façon uniforme sur de nombreux agents ; nous les expliquons dans MCP expliqué simplement.

Vérifiez-vous Un agent a accès à deux outils, « envoyer_courriel » et « creer_brouillon ». Vous lui demandez de « préparer une réponse au client ». Lequel devrait-il choisir, et qui décide vraiment ?

Il devrait choisir « creer_brouillon », puisque vous avez demandé de préparer et non d’envoyer. Mais c’est le modèle qui fait ce choix à partir de votre phrase et des descriptions des outils : s’il interprète mal la consigne, il peut envoyer. La protection la plus sûre se place dans le programme, par exemple en exigeant votre confirmation avant tout appel à « envoyer_courriel ».

Ce qui guide chaque choix

À chaque tour, la décision de l’agent dépend de plusieurs ingrédients, tous placés dans sa fenêtre de contexte :

• Les instructions de départ : le prompt système fixe le rôle, les règles et les interdits.
• Votre demande : plus elle est précise, moins l’agent a à deviner.
• Les descriptions des outils : elles délimitent ce qu’il peut faire.
• L’historique de la tâche : chaque pensée, action et observation précédente.
• Sa mémoire, si elle existe : préférences ou souvenirs de tâches passées, rappelés au bon moment par la mémoire d’agent.

Les modèles de raisonnement récents réfléchissent plus longuement avant chaque action. Ils ne remplacent pas la boucle : ils rendent chaque tour plus réfléchi, au prix de plus de temps et de plus de tokens.

Savoir s’arrêter

Une boucle doit finir. Dans le cas idéal, le modèle juge l’objectif atteint et rédige sa réponse. Mais un agent peut aussi tourner en rond, relancer la même recherche ou poursuivre une piste sans issue.

Dans son article « Building Effective Agents » du 19 décembre 2024, Anthropic recommande que l’agent obtienne à chaque étape une « vérité de terrain » de son environnement, comme le résultat d’un outil ou d’une exécution de code, pour évaluer ses progrès. L’éditeur ajoute que l’agent peut faire une pause pour demander l’avis d’un humain à des points de contrôle, et qu’il est courant de prévoir des conditions d’arrêt, comme un nombre maximal d’itérations.

En pratique, on combine trois garde-fous : un nombre maximal d’étapes, un budget en tokens ou en argent, et des points de validation humaine avant les actions sensibles. Chaque tour de boucle consomme des appels au modèle : notre calculateur de coût d’un agent aide à estimer ce que représente une tâche en dix étapes plutôt qu’en deux.

Où les décisions déraillent

Comprendre la boucle permet de repérer ses points faibles :

• Une mauvaise observation : l’agent lit mal une page, et toute la suite s’appuie sur une erreur.
• Les erreurs en cascade : une petite approximation au tour 2 devient un résultat faux au tour 8.
• La boucle infinie : l’agent répète une action qui échoue sans changer de stratégie.
• L’injection de prompt : un texte caché dans une page ou un document se fait passer pour une instruction et détourne la décision suivante. C’est l’injection de prompt.
• L’objectif ambigu : face à une consigne floue, l’agent comble les trous à sa façon.

Pour aller plus loin, voyez jusqu’où ces décisions peuvent être laissées sans surveillance dans notre article sur les agents IA autonomes.