Une équipe logicielle travaille rarement dans une seule interface. Un architecte inspecte un diff sur bureau le matin, la CI lance une vérification console à midi et un portail interne appelle un moteur d'agent par API le soir. Les assistants propriétaires enferment ces usages dans des extensions closes et une télémétrie cloud opaque. Comme détaillé dans Tendances de l'Écosystème des Agents IA Open Source en Novembre 2026, les équipes adoptent désormais des moteurs locaux et ouverts.
Goose est un agent de codage IA open source écrit en Rust, publié sous licence Apache-2.0 et transféré par Block vers l'Agentic AI Foundation (AAIF) de la Linux Foundation. Exécuté localement en application de bureau, CLI ou démon API/GDK chiffré par TLS, il orchestre 15+ fournisseurs LLM et 70+ extensions MCP.
Important
- Gouvernance Neutre et Noyau Rust : Hébergé sur aaif-goose/goose sous l'AAIF avec licence Apache-2.0, Goose garantit sûreté mémoire et portabilité locale.
- Trois Modes sur un Moteur Unique : Le même noyau anime l'app bureau (macOS, Windows, Linux), la CLI
gooseet le serveur REST/SSEgoose serve(goosed) complété par le GDK. - Indépendance Modèle et MCP-First : Associe 15+ fournisseurs LLM (Anthropic, OpenAI, Google, Ollama hors ligne, OpenRouter, Azure, Amazon Bedrock), 70+ serveurs MCP et recettes YAML.
Pourquoi Rust, Apache-2.0 et l'AAIF Réduisent le Risque Architectural
Les bancs d'essai de modèles évoluent chaque trimestre, tandis que la gouvernance et l'architecture d'exécution déterminent le risque pluriannuel. Un outil lié à un seul fournisseur de modèles expose l'équipe aux hausses tarifaires, au routage cloud imposé et à la fermeture d'API d'extension.
Goose lève ce verrou sur deux plans. D'abord, bien que Block ait créé block/goose (qui redirige vers aaif-goose/goose), la gouvernance relève désormais de l'Agentic AI Foundation (AAIF) au sein de la Linux Foundation. Avec la licence permissive Apache-2.0, une entreprise peut auditer le code, créer des extensions privées et embarquer le moteur dans des produits commerciaux sans friction copyleft.
Ensuite, le choix de Rust surpasse les orchestrateurs interprétés. Un agent lance sans cesse des sous-processus, diffuse des flux de jetons et gère plusieurs sessions Model Context Protocol (MCP) en parallèle. Le binaire Rust démarre vite, évite la dérive des environnements Python entre postes et CI, et garde une mémoire stable. La documentation goose-docs.ai aligne bureau, terminal et serveur autour d'une configuration unique.
Trois Formes d'Exécution sur un Seul Moteur
Goose sépare le moteur d'orchestration de la couche cliente pour partager profils, autorisations et recettes entre trois modes natifs.
Application de Bureau Multiplateforme et MCP App
Packagée pour macOS, Windows et Linux, l'application de bureau offre un espace graphique structuré aux ingénieurs et analystes sécurité. Elle affiche les extensions MCP App avec contrôles d'approbation et sorties structurées. En lisant le même ~/.config/goose/config.yaml que la CLI, toute configuration testée visuellement s'exécute à l'identique en automatisation.
CLI de Terminal (goose)
Pour tmux, Neovim ou les pipelines CI/CD, la CLI goose opère directement dans le dépôt : édition de fichiers, tests, diagnostic de compilation en mode interactif ou sans tête. L'option CONFIGURE=false assure une installation non interactive dans des exécuteurs CI éphémères.
Démon API (goosed / goose serve), ACP et GDK
goose serve (adossé à goosed) expose une API REST et des flux Server-Sent Events (SSE) sécurisés par TLS et GOOSE_SERVER__SECRET_KEY :
/sessionspour créer et superviser les sessions concurrentes,/sessions/{session_id}/openpour attacher un client et recevoir les événements via SSE,/sessions/{session_id}/extensionspour restreindre les extensions MCP par session.
Parallèlement, goose-acp-server implémente l'Agent Client Protocol (ACP) pour les éditeurs externes et le Goose Development Kit (GDK) permet d'embarquer le runtime dans des applications, serveurs et navigateurs. Avec le GDK, un portail interne de développeurs ou une console d'exploitation pilote directement des sessions goosed et diffuse les appels d'outils en temps réel sans réécrire la boucle d'orchestration. Pour les plateformes internes construites via Solutions d'Intelligence Artificielle, cela supprime les surcouches CLI fragiles.
Installation, Configuration Multi-LLM et Démon TLS
Goose supporte nativement plus de 15 fournisseurs LLM — Anthropic, OpenAI, Google, Ollama hors ligne, OpenRouter, Azure et Amazon Bedrock — ainsi que les abonnements existants via goose configure ou des variables d'environnement (ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY).
# 1. Installation officielle de Goose CLI (Linux / macOS)
curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
# Alternative : Homebrew sur macOS ou installation non interactive en CI
brew install block-goose-cli
CONFIGURE=false curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
# 2. Verifier l'installation et configurer le fournisseur LLM
goose --version
export ANTHROPIC_API_KEY="sk-ant-..."
goose configure
# 3. Demarrer le demon API TLS avec secret partage et planificateur
GOOSE_SERVER__SECRET_KEY='VOTRE_SECRET_ROBUSTE' \
goose serve --platform desktop --enable-scheduler --host 0.0.0.0 --port 3000 --tls
Astuce
En réseau isolé ou environnement réglementé, sélectionnez Ollama dans goose configure pour garder prompts, diffs et outils sur le matériel local. Les recettes YAML restant découplées du fournisseur, un flux validé hors ligne passe sans modification sur Amazon Bedrock ou Azure en production.
Extensibilité MCP-First et Recettes YAML Portables
Co-contributeur précoce de MCP, Goose relie plus de 70 extensions ouvertes via goose configure, goose mcp ou ~/.config/goose/config.yaml. Les équipes créant des serveurs MCP stdio — selon les schémas de notre Guide d'Architecture et de Configuration MCP de REA (Reverse Engineer Anything) — déclarent leurs binaires directement en YAML :
# ~/.config/goose/config.yaml
extensions:
github:
type: stdio
name: github
cmd: npx
args:
- "-y"
- "@modelcontextprotocol/server-github"
enabled: true
timeout: 300
postgres_readonly:
type: stdio
name: postgres_readonly
cmd: uvx
args:
- "mcp-server-postgres"
enabled: true
timeout: 120
Pour industrialiser les tâches récurrentes, Goose regroupe instructions, parameters typés, sous-recettes et bloc extensions isolé dans des recettes YAML versionnées. Quand le bloc extensions est déclaré, seuls ces outils sont chargés selon le moindre privilège :
# ./ci-review.yaml
version: 1.0.0
title: "Revue Securite et Architecture par Branche"
description: "Audite les modifications recentes sur une branche Git et produit un rapport structure."
parameters:
- key: branch
input_type: string
requirement: required
description: "Nom de la branche Git a auditer"
- key: strict_mode
input_type: boolean
requirement: optional
default: "true"
description: "Appliquer les verifications strictes de typage et de validation"
extensions:
- type: builtin
name: developer
instructions: |
Analyse les changements de la branche {{ branch }}.
Avec strict_mode={{ strict_mode }}, controle la surete de typage, la validation des entrees,
la gestion d'erreurs et la couverture de tests. Produis une synthese Markdown actionnable.
goose recipe validate ./ci-review.yaml
goose run --recipe ./ci-review.yaml --params branch="main"
Les recettes validées s'exécutent à la demande en CI ou périodiquement via goose serve --enable-scheduler. Dans les dépôts d'envergure, les sous-recettes permettent d'enchaîner des étapes spécialisées — audit des dépendances, revue architecturale de pull requests et synthèse de notes de version — en accordant à chaque étape uniquement les extensions MCP requises. Versionnées dans Git, ces règles deviennent des actifs d'équipe reproductibles plutôt que des conversations éphémères isolées.
Comparaison Architecturale : Goose, OpenCode, OpenHands et Agents Propriétaires
Pour une boucle légère en terminal consultez le Guide de l'Agent de Codage Terminal Open Source OpenCode ; pour l'exécution autonome cloisonnée en conteneur référez-vous au Guide de l'Agent Logiciel Autonome en Sandbox OpenHands.
| Dimension Architecturale | Goose | OpenCode | OpenHands | Agents Propriétaires |
|---|---|---|---|---|
| Modes d'Utilisation | Bureau (macOS/Win/Linux), CLI, API REST/SSE goose serve, ACP et GDK | CLI terminal et TUI interactive | Web conteneurisé, CLI et API autonome | Extension d'IDE ou cloud fermé |
| Moteur et Isolation | Binaire Rust natif sur l'hôte ; démon TLS optionnel | Processus terminal local léger | Isolation complète en conteneur Docker / sandbox | Cloud géré ou binaire fermé |
| Gouvernance et Licence | Apache-2.0 sous AAIF (Linux Foundation) | Dépôt communautaire open source | Dépôt communautaire open source | Licence commerciale propriétaire |
| Verrouillage Modèle | Aucun ; 15+ fournisseurs LLM, abonnements et Ollama hors ligne | Routage multi-fournisseurs | Multiples backends LLM configurables | Souvent un fournisseur ou palier clos |
| Protocoles et Automatisation | MCP-first (70+ extensions), ACP, recettes YAML et planificateur | Terminal avec support MCP | Résolution autonome multi-étapes en sandbox | Plugins propriétaires et flux cloud |
OpenCode brille par sa sobriété en terminal ; OpenHands impose la conteneurisation jetable pour le code non fiable. Goose unifie bureau, CI, API/GDK et recettes YAML dans un unique noyau Rust Apache-2.0.
Sécurité Entreprise et Déploiement avec Kling Digital
L'exécution native garantit réactivité et accès aux outils locaux tout en exigeant des garde-fous explicites.
Avertissement
Contrairement aux sandboxes conteneurisés, Goose exécute les commandes et serveurs MCP stdio directement sur l'hôte sauf encapsulation dans votre propre conteneur ou VM. N'exposez jamais goose serve sur --host 0.0.0.0 sans --tls, une clé GOOSE_SERVER__SECRET_KEY robuste et un filtrage réseau strict ; limitez les recettes automatisées aux jetons en lecture seule dès que possible.
Kling Digital applique quatre contrôles en production :
- Catalogue de Recettes Git : Vérifiez chaque recette en pull request avec
goose recipe validate. - Politique Multi-Fournisseurs : Associez les dépôts sensibles à Ollama local ou aux points d'accès Bedrock et Azure.
- MCP au Moindre Privilège : Imposez des jetons restreints, un
timeoutexplicite et des blocsextensionsminimaux. - Proxy Authentifié devant
goosed: Protégez/sessionset/sessions/{session_id}/extensionspar authentification d'identité.
Kling Digital conçoit des architectures d'agents open source, serveurs MCP sur mesure et intégrations GDK via Développement Logiciel et Solutions d'Intelligence Artificielle. Pour évaluer Goose dans votre organisation, échangez avec nos architectes via Contact.




