Le Guide Complet de Goose : L’Agent de Développement IA Open-Source de Block pour 2026

Date de publication : mars 2026 · Version : v1.0+ · Licence : Apache 2.0 · Mode d’exécution : Local

Début 2026, Block (anciennement Square) a officiellement rendu open-source Goose — un agent IA capable d’accomplir de manière autonome des tâches de développement complexes. Contrairement aux outils de complétion de code traditionnels, Goose ne se contente pas de générer du code : il exécute indépendamment des commandes, débogue des erreurs, orchestre des workflows et peut même construire des projets complets à partir de zéro.

La philosophie fondamentale de Goose est celle de l’« on-machine AI agent » (agent IA sur machine locale) : toutes les tâches s’exécutent localement, garantissant la confidentialité et la sécurité du code. Il prend en charge n’importe quel fournisseur de LLM, permet des stratégies multi-modèles configurables pour optimiser les performances et les coûts, et intègre de manière transparente des outils et services externes via le protocole MCP (Model Context Protocol).

Pourquoi choisir Goose ?

Comparaison des fonctionnalités principales

Caractéristique	Goose	GitHub Copilot	Cursor	Devin
Licence open-source	✅ Apache 2.0	❌ propriétaire	❌ propriétaire	❌ propriétaire
Exécution locale	✅ entièrement local	❌ cloud	⚠️ hybride	❌ cloud
Exécution autonome	✅ peut exécuter des commandes	❌ suggestions uniquement	⚠️ limité	✅
Support multi-modèles	✅ n’importe quel LLM	❌ fixe	⚠️ limité	❌ fixe
Intégration MCP	✅ support natif	❌	❌	❌
Orchestration de workflows	✅ autonome	❌	⚠️	✅
Prix	✅ gratuit	$10-19/mois	$20/mois	$500/mois

Scénarios d’utilisation

✅ Recommandé pour :

Automatiser les tâches de développement répétitives
Protéger la confidentialité du code avec exécution locale
Choisir librement son fournisseur de LLM
Construire des workflows complexes en plusieurs étapes
Développeurs individuels/équipes avec budget limité

❌ Moins adapté pour :

Simple complétion de code uniquement
Manque de familiarité avec la ligne de commande
Besoin d’un support SLA de niveau entreprise

Démarrage rapide

Configuration système requise

Système d’exploitation : macOS 12+ / Windows 10+ / Linux (Ubuntu 20.04+)
Mémoire : minimum 8 Go, recommandé 16 Go+
Stockage : au moins 2 Go d’espace disponible
Python : 3.10 ou supérieur
Node.js : 18+ (optionnel, pour certaines extensions)

Méthodes d’installation

Méthode 1 : Avec pip (recommandé)

# Installer Goose
pip install goose-ai

# Vérifier l'installation
goose --version

Méthode 2 : Depuis les sources

# Cloner le dépôt
git clone https://github.com/block/goose.git
cd goose

# Installer les dépendances
pip install -e .

# Construire l'application de bureau (optionnel)
npm install && npm run build

Méthode 3 : Avec Homebrew (macOS)

brew install goose-ai

Configuration initiale

Au premier lancement, Goose nécessite la configuration du fournisseur de LLM :

# Lancer l'assistant de configuration
goose configure

# Ou éditer manuellement le fichier de configuration ~/.config/goose/config.yaml

Exemple de fichier de configuration :

providers:
  - name: openai
    api_key: ${OPENAI_API_KEY}
    models:
      - gpt-4o
      - gpt-4-turbo
  
  - name: anthropic
    api_key: ${ANTHROPIC_API_KEY}
    models:
      - claude-3-5-sonnet
      - claude-3-opus
  
  - name: ollama
    base_url: http://localhost:11434
    models:
      - qwen3-coder:32b
      - llama3:70b

default_model: claude-3-5-sonnet
workspace: ~/projects

Fonctionnalités principales en détail

1. Exécution autonome de tâches

La capacité la plus puissante de Goose est l’exécution autonome de tâches en plusieurs étapes. Par exemple, créer un service API complet :

# Dites à Goose ce dont vous avez besoin
goose run "Crée un projet FastAPI avec inscription utilisateur, connexion et authentification JWT"

Goose va automatiquement :

Créer la structure du projet et les fichiers nécessaires
Écrire les routes, modèles et logique d’authentification
Installer les paquets de dépendances
Exécuter les tests pour valider les fonctionnalités
Générer la documentation API

2. Intégration de serveurs MCP

Goose prend nativement en charge le protocole MCP (Model Context Protocol) et peut se connecter à divers outils externes :

# Ajouter des serveurs MCP dans le fichier de configuration
mcp_servers:
  - name: filesystem
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "~/projects"]
  
  - name: github
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_TOKEN: ${GITHUB_TOKEN}
  
  - name: postgres
    command: npx
    args: ["-y", "@modelcontextprotocol/server-postgres"]
    env:
      DATABASE_URL: postgresql://localhost:5432/mydb

Serveurs MCP couramment utilisés :

Serveur	Fonction	Commande d’installation
filesystem	Opérations sur le système de fichiers	`@modelcontextprotocol/server-filesystem`
github	API GitHub	`@modelcontextprotocol/server-github`
postgres	Base de données PostgreSQL	`@modelcontextprotocol/server-postgres`
slack	Messages Slack	`@modelcontextprotocol/server-slack`
puppeteer	Automatisation du navigateur	`@modelcontextprotocol/server-puppeteer`

3. Stratégies multi-modèles

Goose permet d’utiliser différents modèles selon le type de tâche pour optimiser les coûts et les performances :

routing:
  # Génération de code avec modèle haute performance
  code_generation:
    model: claude-3-5-sonnet
    max_tokens: 4096
  
  # Tâches simples avec modèle local
  simple_tasks:
    model: ollama/qwen3-coder:7b
    max_tokens: 2048
  
  # Revue de code avec modèle économique
  code_review:
    model: gpt-4o-mini
    max_tokens: 1024

4. Système d’extensions

Goose prend en charge les extensions personnalisées pour ajouter des capacités spécifiques à un domaine :

# extensions/my_extension.py
from goose.extensions import Extension

class MyExtension(Extension):
    """Exemple d'extension personnalisée"""
    
    def __init__(self):
        self.name = "my-extension"
        self.version = "1.0.0"
    
    async def deploy_to_server(self, project_path: str):
        """Logique personnalisée de déploiement sur serveur"""
        # Implémenter la logique de déploiement
        pass
    
    async def run_tests(self, project_path: str):
        """Logique personnalisée d'exécution des tests"""
        # Implémenter la logique de test
        pass

Exemples pratiques

Exemple 1 : Migration de données automatisée

# Créer une tâche de migration
goose run "
  Migre les données utilisateurs de MySQL vers PostgreSQL :
  1. Lire la table users de MySQL
  2. Convertir la structure de données pour PostgreSQL
  3. Écrire dans la base PostgreSQL
  4. Vérifier l'intégrité des données
  5. Générer un rapport de migration
"

Exemple 2 : Refactoring de code en masse

# Refactoriser la gestion d'erreurs de tout le projet
goose run "
  Refactorise la gestion d'erreurs de tous les fichiers Python du projet :
  - Utiliser uniformément des classes d'exceptions personnalisées dans les blocs try-except
  - Ajouter une journalisation appropriée
  - Ajouter une logique de retry pour tous les appels API
  - Mettre à jour les cas de test pour couvrir les nouvelles exceptions
"

Exemple 3 : Génération de documentation API

# Générer une documentation API complète à partir du code
goose run "
  Analyse les routes API du projet et génère :
  1. Fichier de spécification OpenAPI 3.0
  2. Documentation utilisateur au format Markdown
  3. Fichier de collection Postman
  4. Page de test API interactive
"

Meilleures pratiques

1. Configuration de sécurité

# Restreindre le périmètre des permissions de Goose
security:
  # Liste blanche des commandes autorisées
  allowed_commands:
    - git
    - npm
    - pip
    - python
    - docker
  
  # Répertoires interdits
  blocked_paths:
    - ~/.ssh
    - /etc/passwd
    - /etc/shadow
  
  # Opérations dangereuses nécessitant une confirmation
  require_confirmation:
    - rm -rf
    - DROP TABLE
    - DELETE FROM

2. Optimisation des performances

# Configuration d'optimisation
performance:
  # Nombre maximum de tâches en parallèle
  max_concurrent_tasks: 4
  
  # Délai d'expiration par tâche (secondes)
  task_timeout: 300
  
  # Activer le cache
  cache:
    enabled: true
    ttl_hours: 24
  
  # Sortie en streaming (moins de mémoire)
  streaming: true

3. Journalisation et débogage

# Activer la journalisation détaillée
goose run "Description de la tâche" --verbose

# Afficher l'historique d'exécution
goose history --limit 10

# Exporter le rapport de session
goose report --format markdown --output session-report.md

Questions fréquentes

Q1 : Quelle est la différence entre Goose et Cursor ?

R : Cursor est un plugin IDE qui offre principalement de la complétion de code et des fonctionnalités de chat. Goose est un agent IA autonome qui peut exécuter des commandes et orchestrer des workflows. Les deux peuvent être combinés : Goose pour les tâches d’automatisation et Cursor pour le développement interactif.

Q2 : Puis-je utiliser des modèles locaux ?

R : Oui ! Goose prend en charge des backends d’inférence locaux comme Ollama et LM Studio. Exemple de configuration :

providers:
  - name: ollama
    base_url: http://localhost:11434
    models:
      - qwen3-coder:32b

Q3 : Comment protéger les informations sensibles ?

R : Goose prend en charge les variables d’environnement et la configuration chiffrée :

# Utiliser une variable d'environnement
export OPENAI_API_KEY="sk-..."
goose run "Tâche"

# Ou utiliser un fichier de configuration chiffré
goose config encrypt

Q4 : Le français est-il supporté ?

R : Oui ! Utilisez des modèles optimisés pour le français (comme Claude, GPT-4o ou Qwen3 Coder) pour de meilleurs résultats.

Communauté et ressources

GitHub : https://github.com/block/goose
Documentation officielle : https://block.github.io/goose/
Communauté Discord : https://discord.gg/goose-oss
Liste des serveurs MCP : https://github.com/modelcontextprotocol/servers

Conclusion

Goose représente une nouvelle direction pour les outils de développement IA en 2026 : de l’« aide à la programmation » vers le « développement autonome ». Grâce à l’exécution locale, au support multi-modèles et à l’intégration de l’écosystème MCP, Goose offre aux développeurs une plateforme d’agent IA puissante, flexible et respectueuse de la vie privée.

Pour les équipes souhaitant automatiser des tâches de développement complexes, protéger la confidentialité de leur code ou construire des workflows IA personnalisés, Goose est un outil qui vaut le coup d’être adopté. Avec la maturation de l’écosystème MCP et les extensions de la communauté, les capacités de Goose continueront de s’étendre.

Ressources connexes :

#Goose #Block #IA Open-Source #Agent IA #Développement Automatisé #MCP