Les agents IA ne se contentent plus de répondre à une question : ils peuvent désormais observer, agir, vérifier leur travail et recommencer jusqu’à obtenir le résultat attendu. Encore faut-il leur expliquer quand s’arrêter. Sinon, vous obtenez un stagiaire infatigable… équipé de la carte bancaire de l’entreprise.

Claude Code met enfin de l’ordre dans les boucles IA : /goal, /loop et /schedule expliqués

Le 6 juillet 2026, l’équipe de Claude Code, l’outil de programmation agentique développé par l’entreprise américaine Anthropic, a publié sur le compte ClaudeDevs une clarification particulièrement attendue sur les « boucles » utilisées par les agents IA. Rédigé par Delba de Oliveira, le guide distingue quatre manières de faire travailler Claude : les boucles pilotées par l’utilisatrice, les boucles orientées vers un objectif, les boucles déclenchées à intervalles réguliers et les boucles proactives exécutées sans intervention humaine directe. Ces fonctions concernent principalement Claude Code, dans le terminal, sur le Web ou dans le cloud. L’accès commence avec l’abonnement Claude Pro à 20 dollars par mois, tandis que les usages intensifs peuvent entraîner une facturation complémentaire liée aux tokens consommés.

Une boucle IA est un cycle dans lequel un agent analyse une situation, agit, vérifie le résultat puis recommence jusqu’à ce qu’une condition d’arrêt soit remplie.

Claude distingue quatre niveaux :

• la boucle manuelle, relancée par un nouveau prompt ;
• la boucle /goal, qui travaille jusqu’à atteindre un résultat mesurable ;
• la boucle /loop, qui relance une vérification à intervalles réguliers ;
• la routine proactive, déclenchée automatiquement par une heure, une API ou un événement GitHub.

La bonne question n’est donc plus seulement : « Quel prompt dois-je écrire ? », mais aussi : « Qu’est-ce qui déclenche le travail, comment vérifier le résultat et quand l’agent doit-il s’arrêter ? »

Pourquoi parle-t-on soudainement autant de « boucles » ?

Pendant plusieurs années, l’utilisation des IA génératives s’est concentrée sur le prompt : une personne écrit une consigne, le modèle répond, puis attend la suite.

Avec les agents IA, ce fonctionnement devient plus dynamique. L’agent peut utiliser des outils, consulter des fichiers, lancer des commandes, contrôler un résultat et corriger ses propres erreurs.

La boucle agentique peut être résumée ainsi :

Déclencheur → analyse du contexte → action → vérification → décision de continuer ou de s’arrêter

Anthropic définit ainsi une boucle comme un agent qui répète des cycles de travail jusqu’à ce qu’une condition d’arrêt soit satisfaite. La société propose de distinguer les boucles selon quatre critères : leur déclencheur, leur condition d’arrêt, la fonction Claude Code utilisée et le type de mission auquel elles sont adaptées.

Cette clarification est bienvenue. Sur les réseaux sociaux, le mot « boucle » désignait parfois une simple automatisation programmée, parfois un agent autonome, parfois encore une architecture composée de plusieurs agents. Tout le monde parlait donc de la même chose… mais pas vraiment.

1. La boucle par tours : le prompt classique devient déjà une mini-boucle

Comment fonctionne-t-elle ?

La boucle par tours, ou turn-based loop, est déclenchée par un prompt humain.

Claude rassemble les informations disponibles, réalise une ou plusieurs actions, vérifie son travail puis fournit une réponse. L’utilisatrice décide ensuite de lancer ou non un nouveau tour.

Par exemple :

Analyse cette page Web, corrige les erreurs d’accessibilité, teste le résultat et indique les modifications effectuées.

Claude peut alors :

1. lire le code ;
2. repérer les problèmes ;
3. modifier les fichiers ;
4. lancer des tests ;
5. présenter le résultat.

C’est la boucle la plus simple et souvent la plus appropriée pour une tâche ponctuelle. Anthropic recommande d’ailleurs de ne pas construire une machinerie complexe lorsqu’un bon prompt et une vérification claire suffisent.

Pour quels usages ?

Cette boucle convient notamment pour :

• corriger un bug isolé ;
• produire un premier prototype ;
• analyser un fichier ;
• générer un rapport ponctuel ;
• documenter un processus ;
• préparer une campagne marketing.

Le conseil IAPratique.com

Ajoutez systématiquement une phase de vérification à votre prompt :
Avant de considérer la tâche comme terminée, vérifie que tous les critères demandés sont respectés. Liste les contrôles réalisés et signale clairement ce qui n’a pas pu être vérifié.Ce n’est pas spectaculaire, mais cela évite le célèbre « Tout est terminé » prononcé avec assurance alors que le bouton principal ne fonctionne plus.

2. La boucle orientée objectif avec /goal

Le principe

La commande /goal permet de définir une condition de réussite. Claude continue alors à travailler jusqu’à ce que cette condition soit satisfaite ou que la limite de tentatives soit atteinte.

Contrairement à une boucle classique, ce n’est pas le même agent qui décide seul que son travail est terminé. Après chaque tour, un second modèle plus rapide évalue si l’objectif a réellement été atteint. Si la réponse est négative, Claude reprend le travail avec le motif du refus.

Exemple donné par l’équipe Claude Code :

/goal obtenir un score Lighthouse supérieur ou égal à 90 sur la page d’accueil, arrêter après 5 tentatives

La formulation comporte deux éléments indispensables :

• un résultat mesurable : un score de 90 ;
• une limite : cinq tentatives.

Quand utiliser /goal ?

Cette boucle est particulièrement adaptée lorsque la réussite peut être exprimée par un oui, un non ou une valeur numérique :

• tous les tests passent ;
• le score d’accessibilité dépasse 90 ;
• aucune erreur critique n’apparaît dans les journaux ;
• la liste des tickets à traiter est vide ;
• tous les documents obligatoires ont été produits ;
• le fichier respecte un schéma précis.

La commande /goal nécessite actuellement Claude Code 2.1.139 ou une version plus récente.

Quand éviter /goal ?

Évitez-la lorsque le résultat attendu reste subjectif :

Rends cette page vraiment magnifique. « Magnifique » n’est pas une condition d’arrêt. C’est une invitation à tourner en rond avec élégance.

Préférez des critères comme :

La page doit respecter la charte graphique, obtenir un score Lighthouse supérieur à 90, fonctionner sur mobile et ne produire aucune erreur dans la console.

3. La boucle temporelle avec /loop

Le principe

La commande /loop relance une consigne à intervalles réguliers tant que la session Claude Code reste active.

Exemple :

/loop 15m vérifie si le déploiement est terminé, analyse les erreurs éventuelles et indique-moi le résultat

Claude répète alors la vérification toutes les quinze minutes.

Sans intervalle explicite, Claude peut également choisir lui-même le délai entre deux contrôles, entre une minute et une heure, selon l’évolution de la situation. Il peut vérifier plus fréquemment lorsqu’un déploiement est en cours et ralentir lorsque rien ne bouge.

Les limites à connaître

La commande /loop fonctionne principalement dans la session locale :

• elle nécessite que Claude Code reste actif ;
• fermer la session interrompt les exécutions ;
• les tâches récurrentes expirent après sept jours ;
• une session peut contenir jusqu’à 50 tâches planifiées.

Pour une automatisation durable et indépendante de l’ordinateur, Anthropic recommande de passer par les routines cloud.

Exemples d’utilisation

/loop 30m vérifie l’état de la pull request, traite les commentaires et relance les tests

/loop 1h analyse les nouveaux journaux d’erreurs et signale uniquement les anomalies critiques

/loop 4h contrôle les dépendances nouvellement signalées comme vulnérables

4. Les routines avec /schedule : l’agent travaille même lorsque l’ordinateur est fermé

Les routines Claude Code déplacent l’exécution vers l’infrastructure cloud gérée par Anthropic.

Elles peuvent être déclenchées :

• selon un horaire ;
• par un appel API ;
• par un événement GitHub, comme l’ouverture d’une pull request ou la publication d’une nouvelle version.

Une routine regroupe une consigne, un ou plusieurs dépôts de code et des connecteurs. Elle peut continuer à fonctionner lorsque l’ordinateur de l’utilisatrice est éteint. Les routines sont actuellement proposées en version de recherche sur les abonnements Pro, Max, Team et Enterprise.

Exemple :

/schedule chaque matin à 8 h 30 : analyse les nouveaux tickets, classe-les par urgence, propose une personne responsable et publie un résumé dans Slack

L’intérêt devient évident : l’IA ne se contente plus de répondre lorsqu’on la sollicite. Elle peut surveiller un flux de travail et intervenir lorsque certaines conditions sont réunies.

5. La boucle proactive : plusieurs mécanismes combinés

La boucle proactive représente le niveau le plus avancé présenté par ClaudeDevs.

Elle combine plusieurs briques :

• /schedule pour déclencher la mission ;
• /goal pour définir le résultat attendu ;
• des Skills pour documenter la méthode à suivre ;
• des sous-agents pour répartir les rôles ;
• des hooks pour exécuter automatiquement certaines vérifications ;
• des connecteurs MCP pour accéder aux outils externes ;
• un mode automatique pour limiter les demandes de confirmation.

Un exemple pourrait être :

Chaque heure, consulte le canal de signalement des bugs.

Pour chaque nouveau rapport :
1. vérifie qu’il contient les informations nécessaires ;
2. reproduis le problème ;
3. propose trois solutions ;
4. fais examiner les solutions par un agent relecteur ;
5. prépare un correctif ;
6. arrête-toi lorsque les tests passent et qu’une pull request documentée est prête.

Ne dépasse pas trois tentatives par bug.

Les sous-agents de Claude Code peuvent disposer de leurs propres instructions, outils autorisés, modèles, hooks et compétences. Cela permet, par exemple, de séparer l’agent qui produit le correctif de celui qui doit le contrôler.

C’est une règle saine : l’agent qui a fait le travail ne devrait pas toujours être le seul à noter sa propre copie.

Le tableau pour choisir la bonne boucle

Type de boucle	Déclenchement	Condition d’arrêt	Usage recommandé
Boucle par tours	Prompt humain	Claude estime avoir terminé ou demande du contexte	Missions ponctuelles et exploratoires
/goal	Commande humaine	Objectif atteint ou nombre maximal de tentatives	Résultats mesurables et vérifiables
/loop	Intervalle régulier	Arrêt manuel, fin du travail ou expiration	Surveillance temporaire, tests et déploiements
Routine /schedule	Heure, API ou événement	Objectif de chaque exécution atteint	Tâches récurrentes dans le cloud
Boucle proactive	Événement ou planning	Plusieurs contrôles et objectifs combinés	Flux continus, maintenance et traitement de tickets

Les boucles IA sont-elles réservées aux développeurs ?

Les commandes présentées par Anthropic appartiennent à Claude Code et visent d’abord les métiers techniques. Mais la logique peut être transposée dans de nombreux processus d’entreprise.

Marketing et communication

Une boucle peut :

1. surveiller les nouvelles publications d’un secteur ;
2. éliminer les contenus déjà traités ;
3. sélectionner les informations provenant de sources reconnues ;
4. préparer une synthèse ;
5. contrôler les liens et les dates ;
6. transmettre le résultat à une responsable éditoriale.

Condition d’arrêt possible :

Le document contient dix actualités publiées depuis moins de sept jours, provenant d’au moins cinq sources différentes, avec un lien vérifié pour chaque information.

Support client

Une boucle peut analyser les nouveaux tickets, identifier les urgences, proposer une réponse et transmettre les dossiers sensibles à une personne.

Condition d’arrêt :

Tous les tickets reçus depuis la dernière exécution sont classés, les demandes simples disposent d’un brouillon et les dossiers à risque sont affectés à une responsable.

Finance et gestion

Une boucle peut contrôler les factures, rechercher des doublons ou signaler des écarts inhabituels.

Condition d’arrêt :

Toutes les factures du dossier ont été comparées au bon de commande et les anomalies supérieures à 100 euros sont répertoriées.

La connexion aux logiciels comptables et aux données sensibles doit évidemment être encadrée par des droits d’accès stricts. « L’agent avait accès à tout » reste une explication assez médiocre lors d’un comité de sécurité.

Pilotage de projets

Pour une PME ou une ETI, un agent peut surveiller les tickets Jira, les échéances et les risques d’un portefeuille de projets.

Chaque matin, la boucle pourrait :

• repérer les tâches en retard ;
• identifier les dépendances bloquantes ;
• vérifier les données manquantes ;
• préparer une synthèse pour le comité projet ;
• alerter uniquement lorsqu’une action humaine est nécessaire.

Tutoriel : concevoir sa première boucle IA en sept étapes

Étape 1 — Choisir une tâche répétitive

Commencez par une mission simple, fréquente et suffisamment stable.

Bon exemple : Contrôler chaque matin les nouveaux tickets restés sans responsable.

Mauvais exemple : Gérer entièrement notre transformation numérique.

Une boucle n’est pas une baguette magique. Même avec un joli slash devant.

Étape 2 — Définir le déclencheur

Posez-vous cette question :

Quand le travail doit-il commencer ?

Les principaux déclencheurs sont :

• une demande humaine ;
• une heure précise ;
• un intervalle ;
• l’arrivée d’un fichier ;
• un message dans un canal ;
• la création d’un ticket ;
• une erreur détectée par un outil de supervision.

Étape 3 — Écrire une véritable condition d’arrêt

Une bonne condition d’arrêt doit pouvoir être vérifiée.

Évitez : Arrête-toi lorsque le travail est satisfaisant.

Préférez :Arrête-toi lorsque tous les tickets reçus aujourd’hui disposent d’une catégorie, d’un niveau de priorité et d’une personne responsable.

Étape 4 — Définir les contrôles

Indiquez comment l’agent doit prouver que la tâche est terminée :

• test automatique ;
• comparaison avec une liste de critères ;
• validation d’un schéma ;
• contrôle par un second agent ;
• vérification humaine obligatoire ;
• capture d’écran ;
• journal des actions réalisées.

Anthropic recommande notamment d’enregistrer ces méthodes de vérification dans des fichiers SKILL.md, afin qu’elles soient réutilisées à chaque exécution.

Étape 5 — Fixer les limites

Précisez toujours :

• le nombre maximal de tentatives ;
• la durée maximale ;
• les outils autorisés ;
• les données accessibles ;
• les actions nécessitant une validation humaine ;
• le budget maximal.

Exemple :

Réalise au maximum trois tentatives. Ne modifie aucune donnée de production. Prépare uniquement un brouillon de correctif et demande une validation avant tout déploiement.

Étape 6 — Choisir le bon modèle

Toutes les étapes ne nécessitent pas le modèle le plus puissant.

Une stratégie raisonnable consiste à utiliser :

• un petit modèle rapide pour classifier, surveiller et résumer ;
• un modèle intermédiaire pour produire ou corriger ;
• un modèle plus puissant pour arbitrer une situation complexe ou effectuer la validation finale.

Anthropic recommande précisément de réserver les modèles les plus performants aux décisions nécessitant du jugement et d’utiliser des modèles plus économiques pour les traitements répétitifs.

Étape 7 — Commencer par un pilote

Testez la boucle sur :

• un seul projet ;
• un petit volume de documents ;
• une équipe volontaire ;
• un environnement sans risque ;
• une période limitée.

Analysez ensuite :

• le taux de réussite ;
• les erreurs ;
• les interventions humaines nécessaires ;
• le nombre de tokens consommés ;
• le coût par tâche ;
• le temps réellement économisé.

Claude Code, Codex ou Gemini CLI : qui gère le mieux les boucles ?

Solution	Approche	Point fort	Vigilance
Claude Code	/goal, /loop, /schedule, hooks, Skills et sous-agents	Vocabulaire clair et contrôle précis des conditions d’arrêt	Principalement destiné aux environnements techniques
OpenAI Codex	Automations programmées, Skills et tâches exécutées en arrière-plan	Bonne intégration des tâches récurrentes et file de résultats à réviser	Certaines automatisations liées à un projet local nécessitent que l’application reste active
Gemini CLI	Mode agent, exécution non interactive, MCP, scripts et extensions	Intégration intéressante avec Google Cloud et écosystème open source	Les boucles doivent davantage être assemblées avec des scripts ou des extensions
Zapier Agents	Déclencheurs no-code, applications métiers et actions automatisées	Plus accessible aux équipes marketing, RH ou commerciales	Coûts liés au volume d’actions et contrôle moins fin du raisonnement

OpenAI propose désormais des Automations Codex permettant d’exécuter des tâches récurrentes selon un planning. OpenAI résume sa logique ainsi : les Skills définissent la méthode et les Automations définissent le calendrier.

De son côté, Gemini CLI dispose d’un mode non interactif utilisable dans des scripts et peut se connecter à des serveurs MCP. Google propose également des extensions capables d’embarquer des outils, des commandes et des règles de travail.

La notion de boucle ne dépend donc pas d’un modèle particulier. Claude lui apporte surtout une nomenclature et plusieurs commandes directement accessibles.

Attention au coût des boucles

Plus une boucle exécute de tours, relit de documents et mobilise de sous-agents, plus elle consomme de tokens.

Anthropic estime que, dans ses déploiements en entreprise, Claude Code représente en moyenne environ 13 dollars par développeur et par journée active, soit fréquemment entre 150 et 250 dollars mensuels par développeur. Pour 90 % des utilisateurs observés, le coût resterait inférieur à 30 dollars par journée active. Ces chiffres varient fortement selon le modèle choisi, la taille du dépôt et le nombre d’automatisations exécutées.

Qualité : la boucle ne corrigera pas un mauvais processus

Une boucle reproduit les règles, les documents et les habitudes qu’on lui fournit.

Si les données sont mal structurées, les consignes contradictoires et les responsabilités floues, l’agent exécutera ce désordre plus rapidement. Ce qui est rarement l’objectif officiel du projet.

FAQ sur les boucles IA

Une boucle IA fonctionne-t-elle dans le Claude classique ?

Les commandes /goal, /loop et /schedule présentées ici appartiennent principalement à Claude Code. Elles ne doivent pas être confondues avec une simple conversation sur Claude.ai.

Faut-il savoir coder ?

Pour utiliser directement Claude Code, quelques connaissances techniques restent utiles. En revanche, la logique des boucles peut être mise en œuvre avec des outils no-code comme Zapier Agents, Make, n8n ou des agents intégrés aux logiciels professionnels.

Quelle est la différence entre une automatisation et une boucle IA ?

Une automatisation classique suit généralement des règles fixes. Une boucle IA peut analyser une situation, choisir une action, évaluer le résultat puis adapter l’étape suivante.

Une boucle peut-elle fonctionner sans surveillance humaine ?

Oui, techniquement. Mais les actions sensibles, irréversibles, financières, juridiques ou liées à des données personnelles doivent conserver des étapes de validation humaine.

Comment savoir si une tâche mérite une boucle ?

Une boucle devient pertinente lorsque la tâche revient régulièrement, que les entrées changent, que le résultat peut être vérifié et que l’intervention humaine n’apporte pas de valeur à chaque répétition.

En savoir plus

Documentation et annonces

• Lire l’article original « Getting started with loops » publié par ClaudeDevs
• Comprendre la commande /goal dans Claude Code
• Utiliser /loop et les tâches planifiées
• Créer des routines Claude Code dans le cloud
• Découvrir les Automations de Codex
• Prendre en main Gemini CLI

Articles connexes sur IA Pratique

• Le Concept IA : agent ou assistant ?
• Le MCP : le chaînon manquant entre vos outils et l’IA
• Zapier Agents : créer ses propres collaborateurs IA sans coder
• Comment sauvegarder et industrialiser vos prompts
• L’entreprise autonome arrive : agents IA et opérations sans friction

#IntelligenceArtificielle #ClaudeCode #AgentsIA #Automatisation #PME #ETI #Productivité #MCP #Codex #GeminiCLI #TransformationDigitale