Kling Digital
fr
Contact
2026-11-19
8 MIN LECTURE
Guide En Vedette

OpenHands : Guide de l'Agent Logiciel Autonome en Sandbox Isolé

OpenHands est une plateforme autonome d'ingénierie logicielle open source sous licence MIT, totalement indépendante des fournisseurs de modèles. Dans des sandboxes éphémères Docker ou Kubernetes, elle modifie plusieurs fichiers, installe les dépendances, exécute les tests et corrige les erreurs par itérations. Ce guide détaille son SDK V1, EventStream, les politiques de confirmation, Microagents et MCP.

OpenHands : Guide de l'Agent Logiciel Autonome en Sandbox Isolé

Donner à un agent de codage autonome un accès shell direct sur un poste développeur expose rapidement l'environnement local aux régressions : une mise à jour de dépendance incontrôlée ou un nettoyage agressif suffit à casser plusieurs dépôts. Au sein des tendances de l'écosystème des agents IA open source de novembre 2026, les équipes qui bâtissent des solutions d'intelligence artificielle d'entreprise retiennent OpenHands parce que le bac à sable éphémère forme le cœur de son exécution.

Qu'est-ce qu'OpenHands ? OpenHands (issu d'OpenDevin et d'All-Hands-AI) est une plateforme autonome d'ingénierie logicielle open source sous licence MIT, sans verrouillage fournisseur. Elle crée des sandboxes isolés sous Docker ou Kubernetes où l'agent édite plusieurs fichiers, installe les dépendances, lance les tests et corrige les échecs par itérations sans risquer le système hôte.

Important

Synthèse Exécutive — Les Piliers Techniques d'OpenHands

  • Licence MIT et Neutralité Modèle : Plateforme centrale, Software Agent SDK, CLI et harnais d'évaluation sous licence MIT, compatibles avec les API commerciales et les modèles auto-hébergés.
  • Sandboxes Éphémères Multifichiers : Docker Runtime par défaut et Kubernetes Remote Runtime isolent éditions, paquets et boucles de tests hors du poste hôte.
  • SDK Modulaire V1 et Gouvernance : Réunit EventStream déterministe, politiques (AlwaysConfirm, ConfirmRisky, NeverConfirm), --llm-approve, Microagents et MCP natif avec OAuth.

Architecture Modulaire V1 d'OpenHands et EventStream

OpenHands a adopté une architecture V1 découplée entre le dépôt GitHub officiel OpenHands et le Software Agent SDK, offrant un moteur unique pour l'interface web et les pipelines CI headless.

Découpage des Paquets V1

  • openhands.sdk : Regroupe LLM, Agent, Conversation, Event et politiques de sécurité. Compatible LiteLLM, il permet de changer de fournisseur ou de passerelle interne par variable d'environnement.
  • openhands.tools : Fournit TerminalTool (shell), FileEditorTool (correctifs multifichiers précis) et TaskTrackerTool (planification structurée).
  • openhands.workspace : Abstrait l'exécution entre répertoire local, conteneur Docker éphémère ou environnement distant.
  • openhands.agent_server : Expose l'état de session et les flux via REST et WebSocket pour Agent Canvas (navigateur) et la CLI OpenHands.

Journalisation Déterministe EventStream

Au lieu d'un historique de chat non structuré, OpenHands consigne chaque décision, commande shell, patch et sortie de test dans un EventStream ordonné. Les équipes gagnent un diagnostic reproductible en cas de blocage, une piste d'audit exploitable pour la conformité et une reprise fiable des migrations longues.

Édition Multifichier en Sandbox et Boucles de Tests Autonomes

Corriger une anomalie réelle implique généralement de modifier ensemble modèles de données, services, routes API et tests. OpenHands associe édition coordonnée et vérification isolée.

Docker Runtime, Kubernetes Remote Runtime et Local Runtime

Par défaut, Docker Runtime démarre un conteneur éphémère propre par tâche pour confiner dépendances et builds ; à l'arrêt, le conteneur disparaît et l'hôte reste intact. Pour la CI à grande échelle et les évaluations parallèles, Remote Runtime planifie des pods Kubernetes isolés. Local Runtime reste disponible en option pour les tâches locales légères.

Boucle Fermée Jusqu'aux Tests Verts

Dans le bac à sable, l'agent planifie avec TaskTrackerTool, ajuste les modules interdépendants via FileEditorTool, installe les paquets requis et lance les suites unitaires et d'intégration avec TerminalTool. En cas d'échec, il lit la trace dans EventStream, corrige la cause racine et relance jusqu'au vert. En développement logiciel sur mesure, ce cycle résorbe la dette de tests et sécurise les montées de version.

Installation, CLI Headless, Sandbox Docker et SDK Python

La référence complète est maintenue sur docs.openhands.dev et openhands.dev, avec trois options : CLI locale, Docker ou SDK V1 Python.

Installation CLI, Mode Headless et Commandes MCP

Installez via uv sous Python 3.12 (ou pip install openhands-ai), lancez Agent Canvas avec --mount-cwd (option --gpu), exécutez des tâches headless --llm-approve et configurez MCP :

uv tool install openhands --python 3.12
openhands serve --mount-cwd
openhands --headless --llm-approve \
  --task "Corriger la condition de course du jeton auth et valider pytest"
openhands mcp add docs-interne --url https://mcp.example.internal/sse
openhands mcp list

Démarrage du Conteneur Docker Isolé

Lancez l'application complète avec son image isolée agent-server et la journalisation intégrale :

docker run -it --rm --pull=always \
  -e AGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \
  -e AGENT_SERVER_IMAGE_TAG=1.26.0-python \
  -e LOG_ALL_EVENTS=true \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v ~/.openhands:/.openhands \
  -v $(pwd):/workspace:rw \
  -p 3000:3000 \
  --add-host host.docker.internal:host-gateway \
  --name openhands-app \
  docker.openhands.dev/openhands/openhands:1.8
Avertissement

Périmètre du Socket Docker : Monter /var/run/docker.sock autorise OpenHands à créer des conteneurs frères avec contrôle sur l'hôte. N'activez jamais NeverConfirm sur un poste contenant des clés cloud de production ou clés SSH personnelles ; réservez l'autonomie complète aux runners CI durcis ou à Kubernetes Remote Runtime.

Orchestration Programmatique via SDK V1 Python

Les équipes plateforme intègrent des boucles de correction directement avec openhands.sdk :

import os
from openhands.sdk import LLM, Agent, Conversation, Tool
from openhands.sdk.security.confirmation_policy import ConfirmRisky
from openhands.tools.file_editor import FileEditorTool
from openhands.tools.task_tracker import TaskTrackerTool
from openhands.tools.terminal import TerminalTool
llm = LLM(
    model=os.getenv("LLM_MODEL", "anthropic/claude-sonnet-4-5-20250929"),
    api_key=os.getenv("LLM_API_KEY"),
    base_url=os.getenv("LLM_BASE_URL"),
)
agent = Agent(
    llm=llm,
    tools=[
        Tool(name=TerminalTool.name),
        Tool(name=FileEditorTool.name),
        Tool(name=TaskTrackerTool.name),
    ],
)
conversation = Conversation(agent=agent, workspace=os.getcwd())
conversation.set_confirmation_policy(ConfirmRisky())
conversation.send_message(
    "Corriger l'arrondi des centimes dans la facturation et valider les tests unitaires."
)
conversation.run()

Politiques de Sécurité, Microagents et Support MCP

Le conteneur protège le système hôte, tandis que la gouvernance encadre les commandes autorisées et le respect des standards internes.

Politiques de Confirmation et Analyseur LLM

  • AlwaysConfirm : Suspend chaque commande shell et édition de fichier jusqu'à validation explicite.
  • ConfirmRisky : Politique équilibrée par défaut ; exécute lectures et tests sûrs sans friction et demande validation pour les actions sensibles.
  • NeverConfirm : Exécution continue sans pause, réservée aux sandboxes CI éphémères à droits minimaux.

L'option --llm-approve charge l'analyseur de sécurité LLM d'inspecter la sémantique de chaque commande avant exécution afin de bloquer suppressions destructrices, fuites de secrets ou téléchargements non autorisés.

Microagents et MCP Natif OAuth

Les règles d'architecture sont versionnées en Microagents sous ~/.openhands/microagents/ (compatible avec .agents/skills/), chargées automatiquement selon les chemins ou mots-clés. Le support natif MCP (openhands mcp add, openhands mcp list) gère les serveurs d'entreprise authentifiés par OAuth. Pour l'audit binaire ou les protocoles anciens, les outils du guide d'architecture MCP REA (Reverse Engineer Anything) se branchent sur OpenHands pour traduire l'analyse rétro-ingénierie en code testé dans le même bac à sable.

Astuce

Conseil de Déploiement : Démarrez chaque nouveau dépôt avec ConfirmRisky, --llm-approve et des Microagents sous Git. Auditez EventStream après le premier sprint pour ajuster vos seuils avant de basculer les tâches répétitives en CI headless.

Comparatif Architectural : OpenHands, OpenCode, Goose et Agents Propriétaires

CritèreOpenHandsOpenCodeGooseAgents Propriétaires Cloud / IDE
Modèle d'ExécutionBoucle autonome (Agent Canvas, CLI, Headless, SDK V1 Python)Session interactive native en terminal (TUI)App bureau, CLI et recettes APIExtension IDE fermée ou cloud propriétaire
Isolation SandboxDocker Runtime éphémère et Kubernetes Remote (+ Local)Répertoire local et shell du développeurExécution locale ; conteneur externe optionnelVariable ; cloud éditeur ou IDE local
Tests MultifichiersDépendances, tests complets et correctifs itératifs en conteneurÉdition multifichier assistée et tests terminalChaînes multi-étapes via extensions et recettesHétérogène ; builds et tests souvent limités
Verrouillage ModèleAucun — Licence MIT, modèles commerciaux ou locaux via LiteLLMAucun — Multi-fournisseurs et endpoints locauxAucun — Open source multimodèle flexibleÉlevé — Lié aux modèles ou abonnements maison
MCP et ExtensibilitéMCP natif (openhands mcp add, OAuth), Microagents, SDK V1Large support des serveurs MCP et outilsÉcosystème MCP et recettes YAML réutilisablesConnecteurs restreints au catalogue fermé

Pour la vélocité interactive en terminal, consultez notre guide de l'agent de codage terminal open source OpenCode. Pour unifier bureau, CLI et recettes API, le guide de l'agent IA open source Goose constitue la référence complémentaire. Dès que priment l'isolation par conteneur éphémère, les tests multifichiers autonomes et l'audit EventStream en CI, OpenHands se distingue nettement.

Gouvernance en Production et Pratique Kling Digital

Faire passer OpenHands de l'essai local à une plateforme d'ingénierie gouvernée repose sur quatre garde-fous opérationnels :

  1. Filtrage Strict du Trafic Sortant (Egress) : Restreindre les sorties réseau des conteneurs sandbox aux miroirs internes de paquets et à la passerelle LLM autorisée.
  2. Cloisonnement des Secrets Éphémères : Garder clés API et jetons Git hors du répertoire monté, en émettant des jetons temporaires à privilège minimal limités à la branche active.
  3. Archivage Immuable d'EventStream : Collecter les journaux de LOG_ALL_EVENTS=true dans un stockage d'observabilité centralisé afin que chaque pull request conserve une preuve complète d'exécution.
  4. Revue Humaine Obligatoire et Contrôles SAST : Traiter les tests verts du sandbox comme preuve de vérification et non comme autorisation de fusion ; toute contribution passe par une revue humaine et une analyse SAST.

Kling Digital conçoit des plateformes de codage autonomes sans verrouillage éditeur, des clusters Kubernetes Remote Runtime et des intégrations MCP OAuth sur mesure. Planifiez un atelier d'architecture OpenHands V1 via la page contact Kling Digital.

Foire Aux Questions

Questions fréquemment posées concernant ce guide.

Retour aux Actualités
Partager

Commentaires (0)

Partagez vos réflexions et vos idées avec la communauté.

Aucun commentaire pour le moment. Soyez le premier à commenter !

Laissez un commentaire

Votre commentaire sera publié après validation par un administrateur.

Autorité Thématique & Centre de Ressources

Benchmarks Architecturaux, Guides Piliers & Outils Digitaux

Matrices de référence, guides d'ingénierie B2B et outils interactifs pour orienter vos décisions techniques.

Benchmark Technique

Comparatif Next.js vs WordPress

Chargement sous la seconde, zéro risque lié aux extensions et comparatif du coût total sur 3 ans.

Lire l'Analyse Comparative Complète
Benchmark Architectural

Comparaison Architecturale Framer vs Next.js

Outils de conception visuelle versus développement logiciel d'entreprise complet.

Lire l'Analyse Comparative Complète