Boucles et exécutions autonomes dans Gemini CLI

Certains travaux de code se résument à répéter la même étape jusqu'à ce qu'une condition soit remplie : corriger le code, lancer les tests, lire l'échec, corriger à nouveau. Gemini CLI peut exécuter tout ce cycle pour vous dans une boucle agentique, en éditant des fichiers et en exécutant des commandes jusqu'à ce que la tâche soit réellement terminée ou qu'un garde-fou l'arrête. Cette leçon porte sur la façon de lancer cette boucle de manière délibérée, sans surveillance et en sécurité.

La boucle est le comportement par défaut, pas une astuce

Quand vous donnez une tâche à Gemini CLI, il ne répond pas une fois puis s'arrarrL'Annual Recurring Revenue (ARR) est le revenu normalisé et prévisible qu'une entreprise par abonnement attend de ses contrats actifs sur une année.Voir la définition complète →ête. Il planifie, appelle des outils (lire un fichier, écrire un fichier, exécuter une commande shell), observe le résultat et décide de l'action suivante. Ce cycle observer-puis-agir se répète jusqu'à ce que le modèle estime l'objectif atteint.

C'est le pattern ReAct (reason + act) branché sur un vrai shell. Le changement important pour vous : vous ne rédigez plus un prompt pour obtenir du texte. Vous confiez un objectif et un ensemble d'outils, puis vous laissez l'agent itérer face au feedback réel de votre machine.

Une requête unique convient quand la sortie est la réponse : « explique cette fonction », « écris une regex ». Une boucle convient quand le succès est défini par un contrôle externe que l'agent ne peut pas truquer :

• Itérer jusqu'à ce que la suite de tests passe.
• Appliquer le même refactor en batch sur 40 fichiers.
• Corriger les erreurs de lint et de typage jusqu'à ce que le build soit propre.
• Monter une dépendance de version, puis traiter chaque régression qu'elle provoque.

La distinction tient à l'existence d'une condition d'arrêt vérifiable. Si elle existe, une boucle l'emporte sur un chat, parce que l'agent note son propre travail face à la réalité.

Exécutions non interactives

Le mode interactif est le REPL que vous connaissez déjà. Pour l'automatisation, vous voulez le mode non interactif : une commande, aucun aller-retour, sortie une fois terminé. Utilisez le flag -p (prompt).

gemini -p "Run the test suite with 'npm test'. If anything fails, \
read the output, fix the code, and re-run until all tests pass. \
Do not modify test files." --model gemini-2.5-flash

L'agent est désormais propriétaire de toute la boucle. Il lance npm test, analyse les échecs, édite le source et relance, en bouclant jusqu'au vert ou jusqu'à ce qu'un garde-fou se déclenche.

Deux flags comptent avant tout ici :

• --model choisit le tier. Prenez Flash pour les boucles serrées et bien cadrées (itération rapide et peu coûteuse). Passez à Pro quand le raisonnement est réellement difficile : échecs enchevêtrés, décisions d'architecture, specs ambiguës.
• --yolo approuve automatiquement les appels d'outils pour que la boucle ne s'interrompe jamais en demandant confirmation. Puissant et dangereux. Voir plus bas comment le contenir.

Comme il s'agit d'une simple commande, le mode non interactif s'insère directement dans la CI, cron ou un hook Git. C'est ce que « autonome » veut dire en pratique : personne dans le REPL.

Planification et déclencheurs sans surveillance

Gemini CLI n'embarque pas de planificateur. Vous le branchez sur les outils que vous utilisez déjà. C'est une caractéristique, pas un manque : le CLI reste un citoyen Unix composable.

Un balayage nocturne dépendances-et-tests via cron :

# 2:00 AM daily: attempt upgrades, keep tests green, open a PR
0 2 * * * cd /srv/app && gemini -p "$(cat prompts/nightly-deps.txt)" \
  --yolo --model gemini-2.5-flash >> logs/nightly.log 2>&1

Ou un job GitHub Actions déclenché par une planification ou par des labels d'issue, laissant Gemini CLI faire le triage et préparer une branche de correction. Le pattern est identique : un déclencheur externe lance une exécution non interactive, et cette exécution effectue le bouclage.

Pour la référence officielle des flags et la configuration, voir la [documentation Gemini CLI](https://github.com/google-gemini/gemini-cli).

Exemple pratique : itérer jusqu'à ce que le build passe

Voici une exécution autonome propre et contenue que vous pouvez adapter. Elle plafonne le travail, interdit les manœuvres risquées et produit un résultat relisible plutôt qu'un push silencieux sur main.

#!/usr/bin/env bash
set -euo pipefail

BRANCH="auto/fix-build-$(date +%Y%m%d-%H%M)"
git switch -c "$BRANCH"

gemini --yolo --model gemini-2.5-flash -p '
Goal: make the build and tests pass.
Steps:
  1. Run "npm run build" and "npm test".
  2. If either fails, read the error, make the smallest fix, re-run.
  3. Repeat until both succeed.
Rules:
  - Never edit files under /tests or /node_modules.
  - Never touch package.json versions.
  - If unresolved after 8 attempts, stop and summarize what remains.
'

# Point de contrôle humain : l'agent a créé une branche, nous décidons du merge.
git push -u origin "$BRANCH"
echo "Review the PR before merging: $BRANCH"

Regardez ce qui rend cela sûr plutôt qu'imprudent :

• La condition d'arrêt est externe et objective. « Les deux réussissent » est tranché par les codes de sortie de build et test, pas par l'avis du modèle.
• Le plafond de tentatives est dans le prompt. « 8 tentatives, puis arrêt et résumé » évite une spirale infinie sur une erreur impossible à corriger.
• Les chemins interdits sont explicites. L'agent ne peut pas faire passer les tests en les supprimant, un mode d'échec classique.
• Le résultat atterrit sur une branche. Aucune exécution autonome ne touche votre branche main. Un humain ouvre et merge la PR.

Ce dernier point résume toute la philosophie. L'autonomie couvre le travail. Le merge reste le vôtre.

Conditions d'arrêt : comment les boucles se terminent vraiment

Une boucle agentique se termine pour l'une de ces quatre raisons. Prévoyez-les toutes.

1. Succès. La condition vérifiable est remplie (tests au vert, fichiers traités). C'est le chemin heureux.
2. Limite de tentatives ou de tours. Vous lui avez dit de s'arrêter après N essais. Fixez-la toujours. Les boucles sans plafond, c'est ainsi qu'on découvre un emballement à 3 h du matin.
3. Plafond de coût ou de tokens. L'exécution atteint un budget que vous avez défini (section suivante).
4. Erreur dure dont l'agent ne peut pas se remettre. Credentials manquants, commande inexistante, mur de permissions.

Le cas dangereux n'est aucun des précédents : l'agent croit progresser alors qu'il boucle sur le même correctif cassé. C'est pourquoi « plus petit correctif, relancer » plus un plafond de tentatives vaut mieux qu'un « continue » sans limite. Bornez chaque dimension : tentatives, temps et argent.

Plafonds de coût et contrôle du budget

Une boucle sans surveillance qui appelle un modèle à chaque tour peut faire grimper la dépense sans bruit. Trois couches de défense, de la moins chère à la plus ferme :

Choisissez le modèle en fonction du travail. Flash gère la plupart des boucles itérer-jusqu'au-vert pour une fraction du coût de Pro. N'envoyez pas une boucle de correction de lint à Pro.

Bornez la boucle dans le prompt. Moins de tentatives signifie moins de tours, donc moins de tokenstokensUn token est l'unité de base de texte que traitent les modèles de langage : le plus souvent un fragment de mot, un mot entier ou un signe de ponctuation, plutôt qu'un simple caractère.Voir la définition complète →. Un objectif serré et précis converge plus vite qu'un objectif vague.

Imposez le plafond au niveau du compte. Quand vous passez par l'API Gemini payante ou Vertex AI, définissez budgets et alertes dans la plateforme, pas seulement dans votre prompt. Dans Google Cloud, les budgets et alertes sur Vertex AI vous préviendront (ou couperont la dépense) quelles que soient les décisions de l'agent. C'est votre vrai filet : les limites au niveau du prompt peuvent être contournées par le raisonnement d'un agent perdu, une limite de facturation non.

Une règle pratique : ne lancez jamais --yolo sur une clé payante sans avoir d'abord configuré une alerte budgétaire ferme. Le plafond dans le prompt vous protège des erreurs de logique. Le plafond de facturation vous protège de tout le reste.

Points de contrôle pour le travail sans surveillance

Plus les pouvoirs d'une exécution autonome font peur, plus il faut un point de contrôle entre « l'agent a terminé » et « le changement est en production ». Un point de contrôle est tout checkpoint où un humain ou un contrôle automatisé doit approuver avant que le travail ne se propage.

Empilez-les du moins au plus confiant :

1. Demandes d'approbation (interactif)

Le comportement par défaut. Le CLI s'arrête avant chaque écriture ou commande shell et demande. Très bien pour l'exploration, inutile pour les exécutions sans surveillance puisque personne n'est là pour dire oui.

2. Sandboxing (le point de contrôle par conteneur)

Avant de dégainer --yolo, contenez le rayon d'explosion. Lancez l'agent avec le sandboxing activé pour que les appels d'outils s'exécutent dans un conteneur isolé, pas directement sur votre machine. Même une boucle égarée ne peut pas atteindre de fichiers ou de réseaux hors de la boîte. Activez-le et confinez le répertoire de travail :

gemini --sandbox --yolo -p "$(cat prompts/refactor.txt)"

Combinez le sandboxing avec un checkout git jetable et l'agent ne peut littéralement rien abîmer de ce qui compte pour vous.

3. Le point de contrôle branche-et-PR

Comme dans l'exemple pratique : les exécutions autonomes écrivent sur une branche de feature et ouvrent une pull request. Votre CI existante (tests, scans de sécurité) tourne sur la PR, et un humain approuve le merge. C'est le bon compromis pour la plupart des équipes : autonomie totale à l'intérieur de la boucle, contrôle total à la frontière.

4. La CI comme juge objectif

Ne faites pas confiance au « j'ai fini » de l'agent. Laissez votre pipelinepipelineL'ensemble des opportunités commerciales actives réparties selon les étapes du processus de vente, avec leur valeur potentielle cumulée et leur probabilité de conclusion.Voir la définition complète → trancher. Le travail de l'agent est de produire une branche qui passe la CI. Si la CI échoue, la PR ne merge pas, point final. Cela transforme votre infrastructure de test et de lint existante en arbitre du travail autonome, ce qu'elle sait précisément faire.

Boucles en batch sur de nombreux fichiers

L'autre boucle classique n'est pas « jusqu'à une condition », c'est « pour chaque élément ». Mêmes mécanismes, forme différente.

gemini --yolo --model gemini-2.5-flash -p '
For every *.py file under /src:
  - Add type hints to all public functions.
  - Run "mypy" on the file after editing.
  - If mypy errors, fix and re-check that file before moving on.
Skip files that already pass mypy cleanly. Report a table of files
changed and files skipped when finished.
'

Remarquez la vérification par élément (mypy après chaque édition). Cela garde le batch honnête : l'agent valide chaque fichier avant d'avancer, au lieu d'éditer les 40 et d'espérer. Quand un batch est volumineux et que ses éléments sont indépendants, c'est nettement meilleur que 40 sessions de chat séparées, parce que l'agent conserve le contexte et ses propres contrôles qualité d'une étape à l'autre.

Pour des pipelines structurés et répétables au-delà des exécutions CLI ponctuelles (plusieurs agents spécialisés, orchestration plus riche, évaluation), passez à l'Agent Development Kit (ADK). Le CLI est la voie rapide ; l'ADK est là où vivent les boucles de production avec tests et déploiement en bonne et due forme.

Quand une boucle est le mauvais outil

L'autonomie n'est pas gratuite, ne la dégainez donc pas par réflexe :

• Aucun contrôle objectif n'existe. Si le succès, c'est « améliorer le texte », la boucle n'a rien sur quoi se noter. C'est une requête unique avec relecture humaine.
• Chaque étape demande du jugement. Migrer un flux de paiement n'est pas une boucle qu'on laisse tourner. C'est une série de décisions que vous prenez avec l'agent, en interactif.
• Le coût d'une mauvaise action autonome est élevé et aucun sandbox ne le contient totalement. Gardez alors l'humain dans la boucle.

La boucle justifie son coût précisément quand le contrôle est bon marché et objectif et que le travail est fastidieux. C'est le cas de l'essentiel du labeur dans une base de code, et c'est bien pour cela que le sujet compte.

Points clés

• Utilisez une boucle quand le succès est vérifiable de l'extérieur (tests, build, lint, contrôles de typage) et que le travail est répétitif. Utilisez une requête unique quand la sortie est la réponse ou que chaque étape demande du jugement.
• Exécutez sans surveillance avec `gemini -p`, branchez-le sur cron ou la CI pour la planification, et adaptez le tier de modèle au travail (Flash pour les boucles serrées, Pro pour le raisonnement difficile).
• Bornez chaque boucle sur trois axes : tentatives (dans le prompt), temps et argent (budgets et alertes sur l'APIAPIApplication Programming Interface : une interface standardisée qui permet aux applications de communiquer et d'échanger des données sans connaître leur fonctionnement interne respectif.Voir la définition complète → Gemini ou Vertex AI). Un plafond dans le prompt protège des erreurs de logique ; un plafond de facturation protège de tout le reste.
• Ne lancez jamais `--yolo` nu. Contenez-le avec --sandbox, et faites atterrir le travail autonome sur une branche et une PR pour que votre CI existante soit le juge objectif et qu'un humain soit propriétaire du merge.
• Interdisez explicitement les raccourcis tricheurs (ne pas éditer les tests, ne pas changer les versions) pour que l'agent ne puisse pas satisfaire la condition d'arrêt par le mauvais chemin.