# Utiliser Goose : guide pas à pas de la CLI Goose

URL: https://agentvera.dev/fr/blog/how-to-use-goose/ · Publié: 2026-11-10

Utiliser Goose, l’agent IA open source : installer la CLI, lancer goose configure, choisir un mode, ajouter des extensions MCP, écrire AGENTS.md et lancer des recipes.

**En bref:**

- Installez la CLI Goose avec une commande curl (ou brew install block-goose-cli), laissez goose configure choisir un fournisseur et un modèle, puis lancez goose session dans un projet et décrivez la tâche.
- Goose démarre en mode auto et exécute les outils sans demander. Passez en approve ou smart_approve avec /mode, ou définissez GOOSE_MODE, avant de le lâcher sur un vrai dépôt.
- Les règles du projet vont dans AGENTS.md ou .goosehints, les serveurs MCP sont des extensions dans ~/.config/goose/config.yaml, et goose run --recipe rejoue une tâche depuis un fichier YAML.

Pour utiliser Goose, vous installez la CLI avec `curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash`, vous répondez aux questions de `goose configure` pour choisir un fournisseur et un modèle, puis vous lancez `goose session` dans un projet et décrivez ce que vous voulez. **Goose démarre en mode auto : il exécute donc des commandes sans demander tant que vous ne passez pas en mode approve.**

Ce guide couvre chaque étape de la CLI Goose en novembre 2026 (version 1.58) : installation, configuration, modes, sessions, extensions, fichiers d’instructions et recipes, ainsi que les erreurs qui font perdre le plus de temps.

## Qu’est-ce que Goose ?

Goose est un agent IA généraliste qui tourne sur votre machine. Il existe en CLI, en application de bureau pour macOS, Linux et Windows et en API, le tout écrit en Rust. Il n’est lié à aucun modèle : vous apportez un fournisseur comme Anthropic, OpenAI, Gemini, OpenRouter ou un modèle local, et Goose se charge des appels d’outils, des modifications et du travail dans le shell.

Block a créé Goose et l’a confié à l’[Agentic AI Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation "Agentic AI Foundation"), sous l’égide de la Linux Foundation, en décembre 2025, en même temps que MCP et AGENTS.md. En avril 2026, le dépôt a déménagé vers [aaif-goose/goose](https://github.com/aaif-goose/goose "Goose sur GitHub") et la documentation vers [goose-docs.ai](https://goose-docs.ai "Documentation de Goose"). Les anciens liens vers `block/goose` et `block.github.io/goose` redirigent toujours. Goose est publié sous Apache-2.0, et une nouvelle version sort environ une fois par semaine.

## Étape 1 : installer la CLI

Sous macOS, Linux ou Git Bash sous Windows :

```bash
curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
```

Sous macOS, vous pouvez aussi passer par Homebrew. Les noms des paquets contiennent encore « block » :

```bash
brew install block-goose-cli        # CLI
brew install --cask block-goose     # desktop app
```

Dans Windows PowerShell :

```powershell
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/aaif-goose/goose/main/download_cli.ps1" -OutFile "download_cli.ps1"; .\download_cli.ps1
```

Le binaire Windows est placé dans `%USERPROFILE%\.local\bin`, qu’il faudra peut-être ajouter au `PATH`. Pour mettre à jour plus tard : `goose update`. La CLI et l’application de bureau partagent la même configuration : les fournisseurs et extensions réglés dans l’une apparaissent dans l’autre.

## Étape 2 : lancer goose configure

Le premier lancement démarre `goose configure` tout seul. Trois options s’offrent à vous : vous connecter à OpenRouter, vous connecter à Tetrate Agent Router Service, ou configurer à la main en choisissant un fournisseur, en collant sa clé et en indiquant un modèle. Depuis la version 1.54, il demande aussi dans quel mode démarrer.

Les clés sont stockées dans le trousseau du système (le Trousseau d’accès sous macOS). S’il n’y a pas de trousseau, ou si vous définissez `GOOSE_DISABLE_KEYRING`, elles vont dans un fichier `secrets.yaml` en texte clair. Vous pouvez aussi les exporter :

```bash
export ANTHROPIC_API_KEY=...
export GOOSE_PROVIDER=anthropic
export GOOSE_MODEL=claude-sonnet-5-5
```

Une clé écrite dans `config.yaml` est ignorée. Relancez `goose configure` à tout moment pour changer de fournisseur, ajouter ou activer et désactiver des extensions, ou ouvrir les réglages du mode et des permissions d’outils.

Si vous payez déjà Claude Code ou ChatGPT Plus/Pro, regardez les [fournisseurs ACP](https://goose-docs.ai/docs/guides/acp-providers "Fournisseurs ACP de Goose") : ils permettent à Goose d’utiliser cette connexion au lieu d’une clé API.

## Étape 3 : démarrer une session

```bash
cd my-project
goose session -n checkout-fix
```

Décrivez la tâche avec des mots simples. Touches et commandes utiles dans une session :

- `Ctrl+J` ajoute une nouvelle ligne ; `Ctrl+C` arrête la requête en cours, ou quitte sur une ligne vide.
- `/mode`, `/model`, `/extension` et `/builtin` modifient la configuration sans quitter.
- `/compact` raccourcit la conversation quand elle s’allonge ; `/clear` repart de zéro.
- `/status` affiche la session, avec son ID.

Pour y revenir plus tard, lancez `goose session -r -n checkout-fix`. `goose session list` affiche toutes les sessions, et `--fork` en copie une pour essayer une autre piste sans perdre l’originale.

## Étape 4 : choisir un mode avant le vrai travail

Goose a quatre modes :

| Mode | Ce qu’il fait |
|---|---|
| `auto` (par défaut) | Exécute tous les outils sans demander |
| `approve` | Demande avant chaque appel d’outil |
| `smart_approve` | Demande seulement pour les appels qu’il juge risqués |
| `chat` | Pas d’outils ; discussion seulement |

Changez avec `/mode approve` dans une session, définissez `GOOSE_MODE`, ou choisissez un mode par défaut dans `goose configure`. Pour un contrôle plus fin, réglez des permissions par outil dans `goose configure` ; elles sont enregistrées dans `permission.yaml`. Sur un dépôt auquel vous tenez, commencez en `approve` ou `smart_approve` et relâchez une fois que vous faites confiance à la configuration.

## Étape 5 : extensions et serveurs MCP

C’est par les extensions que Goose obtient ses outils, et chaque serveur MCP est une extension. L’extension Developer (shell et édition de fichiers) est activée par défaut. Parmi les autres extensions intégrées : Computer Controller, Memory et Auto Visualiser.

Pour en ajouter une durablement, lancez `goose configure` → **Add Extension** et choisissez un serveur en ligne de commande (stdio) ou distant (Streamable HTTP). Pour une seule session :

```bash
goose session --with-extension "memory:npx -y @modelcontextprotocol/server-memory"
goose session --with-streamable-http-extension https://example.com/mcp
```

Les extensions enregistrées se trouvent sous `extensions:` dans `~/.config/goose/config.yaml` (Windows : `%APPDATA%\Block\goose\config\config.yaml`). Les serveurs SSE ne sont plus pris en charge ; utilisez Streamable HTTP.

## Étape 6 : AGENTS.md et .goosehints

Goose lit `AGENTS.md`, puis `.goosehints`, à chaque niveau du dossier de travail jusqu’à la racine git, et prend en compte les fichiers imbriqués à mesure qu’il travaille dans les sous-dossiers. Un fichier global dans `~/.config/goose/.goosehints` s’applique à tous les projets.

Si votre projet a déjà un `CLAUDE.md`, inutile de le copier :

```bash
export CONTEXT_FILE_NAMES='["AGENTS.md", ".goosehints", "CLAUDE.md"]'
```

Gardez le fichier court : la stack, comment lancer les tests, ce qu’il ne faut pas toucher et ce que « terminé » veut dire. Notre guide sur [CLAUDE.md et AGENTS.md](/fr/blog/claude-md-agents-md/ "CLAUDE.md et AGENTS.md") explique quoi y mettre.

## Étape 7 : goose run et les recipes

Pour des tâches ponctuelles sans discussion, utilisez `goose run` :

```bash
goose run -t "add a unit test for the price formatter"
goose run -i task.md --output-format json
```

Une recipe est un fichier YAML qui enregistre une tâche avec ses instructions, ses extensions et ses paramètres, pour qu’un collègue ou une tâche planifiée puisse la rejouer :

```bash
goose run --recipe release-notes.yaml --params version=2.4.0
goose schedule add --schedule-id weekly-notes --cron "0 0 9 * * 1" --recipe-source release-notes.yaml
```

`goose recipe validate` vérifie un fichier avant de le partager. Deux autres commandes à connaître : `goose review` demande une revue IA de votre diff git, et `goose info -v` affiche la version et l’emplacement de la configuration, des sessions et des logs.

## Pièges courants

- **Laisser le mode auto activé.** Le mode par défaut exécute des commandes shell sans demander. Changez de mode avant la première tâche sur un vrai dépôt.
- **Suivre une ancienne documentation.** Les tutoriels de 2025 renvoient vers `block/goose` et `block.github.io`. Les commandes fonctionnent encore pour la plupart, mais la documentation à jour est sur goose-docs.ai.
- **Mettre des clés dans config.yaml.** Goose les y ignore. Utilisez le trousseau, `goose configure` ou des variables d’environnement.
- **Utiliser les fournisseurs CLI dépréciés.** Pour travailler avec une connexion Claude Code ou ChatGPT, configurez plutôt un fournisseur ACP.
- **Les longues sessions.** La compaction automatique garde le contexte sous contrôle, mais une nouvelle session nommée par tâche garde des réponses plus précises.

## Faire tourner Goose à côté d’autres CLI dans AgentVera

Goose a sa propre application de bureau, et si Goose est votre seul agent, elle suffit peut-être. Les choses se compliquent quand Goose tourne à côté de Claude Code, Codex ou Gemini CLI sur le même projet. [AgentVera](/fr/ "AgentVera") est une application de bureau qui exécute ces CLI côte à côte dans de vrais terminaux, avec vos propres installations et clés. La [prise en charge de Goose](/fr/agents/goose/ "Goose dans AgentVera") fonctionne ainsi :

- **Une session nommée par agent.** Chaque agent Goose reçoit son propre nom de session, et AgentVera la rouvre avec `goose session --resume --name` aux lancements suivants : la conversation survit à un redémarrage de l’application.
- **Votre fournisseur et vos clés.** Goose continue d’utiliser le fournisseur défini dans `goose configure`. Dans Réglages → Comptes, vous pouvez ajouter des comptes à clé API (Anthropic, OpenAI, OpenRouter, Google) pour les agents Goose.
- **Modèle, effort et rôle.** Le modèle choisi est transmis avec `--model`, le niveau d’effort via `GOOSE_THINKING_EFFORT` et le rôle de l’agent avec `--system`.
- **MCP et le navigateur.** Les serveurs du [MCP manager](/fr/features/mcp-manager/ "MCP manager") d’AgentVera sont transmis en `--with-extension` ou `--with-streamable-http-extension` : vous les configurez une seule fois pour toutes les CLI.
- **Volets, worktrees et revue.** Faites tourner Goose dans la grille du [workspace](/fr/features/workspace/ "Workspace") à côté d’autres agents, chacun dans son propre git worktree, et vérifiez leurs modifications avec la revue de code.

L’offre gratuite comprend jusqu’à 18 agents, MCP, Git, Docker, SSH, la revue de code et les économies de tokens. Pro coûte 9,99 $ par mois ; si vous n’avez jamais eu d’essai, votre première connexion à l’application active Pro pendant 7 jours, sans carte. Pour essayer, [téléchargez AgentVera](/fr/download/ "Télécharger AgentVera").

## En résumé

Trois commandes suffisent pour démarrer avec Goose : l’installation, `goose configure` et `goose session`. Les réglages les plus importants viennent juste après : passer du mode auto au mode approve, ajouter les extensions nécessaires et donner au projet un `AGENTS.md`. Dès qu’une tâche se répète, enregistrez-la comme recipe.

Sources : [installation de Goose](https://goose-docs.ai/docs/getting-started/installation "Installer Goose"), [commandes de la CLI](https://goose-docs.ai/docs/guides/goose-cli-commands "Commandes de la CLI Goose"), [permissions](https://goose-docs.ai/docs/guides/managing-tools/goose-permissions "Modes de permission de Goose"), [extensions](https://goose-docs.ai/docs/getting-started/using-extensions "Utiliser les extensions"), [fichiers de hints](https://goose-docs.ai/docs/guides/context-engineering/using-goosehints "Utiliser .goosehints"), [versions](https://github.com/aaif-goose/goose/releases "Versions de Goose").

## Questions fréquentes

**Goose est-il gratuit ?** Oui. Goose est open source sous licence Apache-2.0 et ne coûte rien. Vous payez votre fournisseur de modèles pour les tokens consommés, ou vous faites tourner un modèle local via Ollama, LM Studio ou Docker Model Runner sans coût de tokens.

**Qui développe Goose aujourd’hui ?** Block a créé Goose et l’a confié à l’Agentic AI Foundation (AAIF), sous l’égide de la Linux Foundation, en décembre 2025. Depuis avril 2026, le code se trouve sur github.com/aaif-goose/goose et la documentation sur goose-docs.ai.

**Goose peut-il utiliser mon abonnement Claude Code ou ChatGPT ?** Oui, grâce aux fournisseurs ACP, qui permettent à Goose de piloter une connexion existante à Claude Code ou à ChatGPT Plus/Pro. Les anciens fournisseurs CLI qui faisaient cela sont dépréciés au profit des fournisseurs ACP.

**Goose lit-il AGENTS.md ou CLAUDE.md ?** Goose lit AGENTS.md puis .goosehints à chaque niveau, du dossier de travail jusqu’à la racine git. Pour charger aussi CLAUDE.md ou .cursorrules, ajoutez-les à la variable d’environnement CONTEXT_FILE_NAMES.

**Goose demande-t-il avant d’exécuter des commandes ?** Pas par défaut. Le mode par défaut est auto, qui exécute les outils sans demander. Le mode approve demande avant chaque appel d’outil, smart_approve seulement pour les appels risqués, et le mode chat désactive les outils.

---

**À propos d’AgentVera.** AgentVera est une app de bureau pour macOS, Windows et Linux, développée par Solviera Teknoloji. Elle exécute 18 agents de code IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) côte à côte, par projet, dans de vrais terminaux avec les installations et connexions CLI de l’utilisateur. L’offre gratuite inclut des agents illimités. Télécharger: https://agentvera.dev/fr/download/ · Tarifs: https://agentvera.dev/fr/pricing/