OpenHands : l'agent de codage IA open source, expliqué
Une présentation d'OpenHands, l'agent de codage IA open source : architecture, configuration locale avec Ollama, correction pratique d'un bug, sécurité et limites, et comparaison avec Claude Code, Cursor et GitHub Copilot.
OpenHands est une plateforme open source pour le développement logiciel augmenté par l'IA, centrée sur un agent capable d'inspecter votre dépôt, d'éditer des fichiers, d'exécuter des commandes et de lancer des tests. Elle s'inscrit dans la tendance du développement logiciel agentique : vous confiez une tâche complète à l'agent, qui l'exécute pas à pas jusqu'à résolution ou besoin de votre avis.
Dans cet article, je vous présente l'architecture d'OpenHands et ses fonctionnalités phares, je vous montre comment le configurer avec un modèle local, puis je le compare à Claude Code, Cursor et GitHub Copilot.
Qu'est-ce qu'un agent IA ? Inscrivez-vous à notre parcours AI Agent Fundamentals pour découvrir comment les agents d'IA peuvent transformer votre façon de travailler.
Qu'est-ce qu'OpenHands ?
OpenHands est une plateforme open source pour créer et exécuter des agents IA spécialisés sur le code.
Le nom recouvre deux réalités : d'abord le projet, un ensemble de dépôts avec un SDK, un serveur, une interface web et un service hébergé ; ensuite l'agent de codage qui s'exécute par-dessus.
Voici le fonctionnement :
SDK d'agent logiciel : un ensemble d'APIs Python et REST pour construire des agents qui travaillent avec du code, et le moteur derrière l'OpenHands CLI et OpenHands Cloud
Agent Server : expose l'exécution des agents, les conversations, les outils et les espaces de travail via des APIs REST et WebSocket
Agent Canvas : une interface web unique pour les conversations, les fichiers, la sortie du terminal, la configuration des modèles, les backends et les automatisations
OpenHands Cloud : le service managé pour les équipes qui ne souhaitent pas opérer leur propre backend et leur propre infrastructure de sandbox
Quand on dit « OpenHands », on parle généralement de l'agent. C'est celui que j'utilise ici.
Le plus souvent, vous lui donnez une tâche logicielle, vous le pointez vers un espace de travail contenant votre code, et il avance avec ses outils. Par défaut : un terminal, un éditeur de fichiers et un suivi de tâches.
L'espace de travail n'a pas besoin d'être votre machine. Les agents peuvent utiliser la machine locale ou s'exécuter dans des workspaces éphémères, par exemple via Docker ou Kubernetes.
OpenHands ne vous enferme pas non plus chez un fournisseur de modèles. Vous pouvez l'utiliser avec Claude, GPT ou tout autre LLM, y compris des modèles locaux. Agent Canvas peut même exécuter des agents tiers comme Claude Code et Codex à la place de l'agent OpenHands par défaut.
En bref, OpenHands est une plateforme d'agents ouverte que vous pouvez opérer selon vos propres règles.
Comment fonctionne OpenHands
OpenHands fonctionne en boucle.
Un assistant de chat reçoit votre invite et répond en texte. L'agent OpenHands, lui, reçoit une tâche, passe à l'action, observe le résultat et décide de la suite.
La boucle de l'agent OpenHands
L'idée générale :
Recevoir la tâche : vous décrivez l'objectif en langage naturel, par exemple : « Corriger le rapport mensuel pour qu'il ne fusionne pas les mois de différentes années »
Inspecter le dépôt : l'agent liste les répertoires, ouvre des fichiers et recherche le code lié à la tâche
Établir un plan : il découpe la tâche en étapes et les enregistre dans son suivi
Modifier ou créer des fichiers : il change le code via son éditeur de fichiers
Exécuter des commandes et des tests : il lance la batterie de tests ou l'application dans le terminal
Analyser les résultats : il lit la sortie, y compris erreurs et assertions échouées
Itérer : si quelque chose cloche encore, il revient en arrière, ajuste le plan et retente
La boucle s'arrête quand la tâche est terminée, ou si l'agent a besoin de quelque chose que vous seul pouvez fournir, comme un identifiant manquant ou une décision sur le besoin.
L'étape 6 différencie OpenHands de la concurrence. Un outil d'autocomplétion ne voit jamais ce qui se passe quand son code s'exécute. OpenHands, si : il peut réagir à un test échoué et corriger la cause.
Fonctionnalités clé d'OpenHands
L'autocomplétion suggère du texte, OpenHands agit sur votre projet. Voici comment.
Édition de code
OpenHands modifie directement les fichiers, et n'est pas limité à un seul fichier à la fois.
Supposons qu'une fonction doive être renommée. L'agent met à jour sa définition, retrouve tous les appels et met à jour les tests qui y font référence – le tout dans une même tâche.
Terminal et usage d'outils
L'agent possède son propre terminal. Il peut installer des dépendances, exécuter des scripts, lancer des tests et lire la sortie de n'importe quelle commande.
Vous pouvez aussi connecter des serveurs MCP (Model Context Protocol) pour lui offrir des outils non prévus initialement, comme un traqueur d'anomalies ou un client base de données.
Compréhension du dépôt
La plupart des générateurs de code ne voient que ce que vous collez dans l'invite.
OpenHands ouvre le dépôt et l'explore. Il peut lire le README, suivre les imports et consulter les tests existants pour comprendre la structure du projet. Résultat : ses modifications ont davantage de chances de s'intégrer harmonieusement au code en place.
Les tâches longues posent un autre problème : l'historique de conversation dépasse la capacité du modèle. OpenHands gère cela avec un « condenseur de contexte » qui résume les parties anciennes pour permettre à l'agent de poursuivre.
Choix du modèle
Les appels modèle passent par LiteLLM, vous pouvez donc utiliser tout fournisseur et modèle pris en charge. La doc OpenHands recommande des modèles des familles Claude, GPT et Gemini, ainsi que des modèles open-weight bien classés dans l'OpenHands Index.
Si votre code ne peut pas quitter votre machine, exécutez un modèle local. OpenHands se connecte à des serveurs locaux comme LM Studio, Ollama, vLLM et SGLang.
Gardez en tête que le modèle influe fortement sur le résultat. Certains modèles locaux peinent à utiliser les outils de manière fiable, même avec une grande fenêtre de contexte.
Exécution autonome des tâches
Une fois la tâche déléguée, l'agent enchaîne la boucle tout seul. Pas besoin de recoller les erreurs dans un chat ni d'indiquer quel fichier ouvrir ensuite.
Agent Canvas va plus loin avec des automatisations. Elles s'intègrent à Slack, GitHub, Linear, etc., et se déclenchent selon un horaire ou via des webhooks.
Mais l'autonomie ne garantit pas la justesse. Vous devez toujours relire le diff et les résultats de tests avant toute fusion.
Comment utiliser OpenHands
Le meilleur moyen de comprendre OpenHands est de lui confier un bug et d'observer.
Dans cette section, j'exécute OpenHands en local avec Docker, je le connecte à un modèle local via Ollama et je lui demande de corriger un bug dans un petit projet Python.
Configurer OpenHands
Vous pouvez lancer OpenHands de plusieurs façons :
Lanceur CLI : installez-le avec uv tool install openhands --python 3.14, puis démarrez l'interface graphique avec openhands serve
Docker : lancez directement le conteneur de l'application avec une seule commande docker run
Agent Canvas : le nouveau client web qui se connecte à des backends locaux, auto-hébergés, Cloud ou Enterprise
OpenHands Cloud : la version hébergée si vous préférez ne rien opérer vous-même
Je vais utiliser la voie Docker avec l'interface locale. La documentation OpenHands la mentionne désormais comme application web Docker dépréciée et oriente vers Agent Canvas pour la remplacer, mais elle reste documentée et c'est le moyen le plus rapide d'obtenir une interface.
Vous aurez besoin de Docker Desktop sur macOS, Linux ou Windows avec WSL. Sur macOS, ouvrez Docker Desktop, allez dans Settings > Advanced et activez le socket Docker par défaut.
Démarrez ensuite l'application :
docker run -it--rm--pull=always \-eAGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \-eAGENT_SERVER_IMAGE_TAG=1.26.0-python \-eLOG_ALL_EVENTS=true \-v /var/run/docker.sock:/var/run/docker.sock \-v ~/.openhands:/.openhands \-p3000:3000 \
--add-host host.docker.internal:host-gateway \--name openhands-app \
docker.openhands.dev/openhands/openhands:1.8Propulsé par
OpenHands utilise le montage du socket Docker pour démarrer un conteneur de sandbox séparé, et l'agent exécute ses commandes dans cette sandbox, pas sur votre hôte.
Une fois que les journaux indiquent que le serveur est en ligne, ouvrez http://localhost:3000 dans votre navigateur.
Page d'accueil d'OpenHands
Connecter un modèle
OpenHands ne fera rien tant que vous ne lui aurez pas fourni un modèle.
J'utilise Devstral Small 2, le modèle 24B de Mistral conçu pour le codage agentique. Il est assez léger pour tourner sur une seule RTX 4090 ou un Mac avec 32 Go de RAM. Il nécessite Ollama 0.13.3 ou version ultérieure.
Démarrez Ollama avec une fenêtre de contexte plus grande et récupérez le modèle :
OLLAMA_CONTEXT_LENGTH=32768OLLAMA_HOST=0.0.0.0:11434 ollama serve &
ollama pull devstral-small-2:24bPropulsé par
Ne sous-estimez pas la longueur du contexte. La valeur par défaut d'Ollama est 4096 tokens, trop faible pour tenir même l'invite système d'OpenHands. La doc recommande au moins 22000.
Dans OpenHands, ouvrez Settings, allez dans l'onglet LLM et activez Advanced. Puis renseignez :
Custom Model :openai/devstral-small-2:latest
Base URL :http://host.docker.internal:11434/v1
API Key : n'importe quelle valeur factice, par exemple local-llm
Paramètres LLM pour un modèle Ollama local
Le préfixe openai/ indique à OpenHands de parler à Ollama via son API compatible OpenAI. La clé API n'est pas utilisée, mais le champ ne peut pas être vide.
Ouvrir un dépôt
Par défaut, OpenHands ne voit pas vos fichiers. Vous devez monter le projet dans la sandbox.
Pour cet exemple, préparez un dossier budget-tracker/project avec deux fichiers. Le premier agrège les dépenses par mois :
# budget.pydefmonthly_totals(transactions):"""Sum spending per month, keyed as 'YYYY-MM'.
Each transaction is a (date, amount) tuple, for example ("2025-01-15", 42.0).
"""
totals ={}for date, amount in transactions:
month = date[5:7]
totals[month]= totals.get(month,0)+ amount
return totalsPropulsé par
La docstring promet des clés au format YYYY-MM, mais date[5:7] ne garde que le mois. Janvier 2025 et janvier 2026 finiront dans le même agrégat.
Le second fichier contient deux tests qui détectent le bug :
Initialisez le dossier en dépôt Git pour visualiser ensuite les changements de l'agent :
cd budget-tracker
git init
gitadd.git commit -m"Initial commit"Propulsé par
Si vous lancez python -m pytest maintenant, les deux tests échouent :
Tests en échec
Pour donner l'accès à OpenHands, arrêtez le conteneur et ajoutez une ligne à la commande docker run :
-eSANDBOX_VOLUMES=$HOME/budget-tracker:/workspace:rw \Propulsé par
La commande complète devient :
docker run -it--rm--pull=always \-eAGENT_SERVER_IMAGE_REPOSITORY=ghcr.io/openhands/agent-server \-eAGENT_SERVER_IMAGE_TAG=1.26.0-python \-eLOG_ALL_EVENTS=true \-eSANDBOX_VOLUMES=$HOME/Desktop/budget-tracker:/workspace:rw \-v /var/run/docker.sock:/var/run/docker.sock \-v ~/.openhands:/.openhands \-p3000:3000 \
--add-host host.docker.internal:host-gateway \--name openhands-app \
docker.openhands.dev/openhands/openhands:1.8Propulsé par
Le format est host_path:container_path:mode. Votre projet apparaît dans la sandbox sous /workspace, et rwautorise l'agent à le modifier.
Ne montez que le projet que vous souhaitez voir modifier. Tout ce qui est monté en lecture-écriture dans /workspace peut être altéré par l'agent.
Donner une tâche à l'agent
Démarrez une nouvelle conversation et décrivez le problème comme dans un ticket :
Les totaux mensuels fusionnent les dépenses du même mois sur différentes années.
Trouvez la cause, corrigez-la et exécutez les tests pour confirmer qu'ils passent.
C'est tout. Inutile d'indiquer budget.py ni de désigner la ligne fautive.
Sortie de conversation
La boucle agent vue plus haut prend le relais. L'agent explore /workspace, lit les deux fichiers et lance les tests pour voir ce qui échoue. Puis il édite le code et relance les tests.
L'agent exécute pytest dans le terminal de la sandbox
Passer en revue les changements
L'agent indique qu'il a terminé. Vous pouvez maintenant afficher les différences en ouvrant l'éditeur de code et en inspectant les modifications.
La correction exacte tient en une ligne dans budget.py :
Vous pouvez également lancer un git diff pour voir les différences.
Vérifiez en particulier :
Le code source : la correction doit être dans budget.py
Les tests : assurez-vous que l'agent n'a pas édité test_budget.py juste pour faire passer les assertions
L'exécution des tests : lancez python -m pytest vous-même : ne vous contentez pas du résumé de l'agent
Architecture d'OpenHands
OpenHands se compose de six briques principales, chacune avec une responsabilité claire.
Comment les composants OpenHands s'articulent
Modèle IA
Le modèle fait le raisonnement. Il reçoit la tâche et l'historique de conversation, et répond par un message ou un appel d'outil.
Le modèle ne modifie pas vos fichiers et n'exécute rien. Il décide seulement de la prochaine action. Les appels passent par LiteLLM, ainsi le même agent fonctionne avec un fournisseur hébergé ou un modèle local comme la configuration Devstral de l'article.
Logique d'agent
L'agent fait l'interface entre le modèle et le reste. Il exécute la boucle « raisonnement-action » : il demande au modèle l'action suivante, appelle l'outil, et gère le résultat ou l'erreur.
Il choisit aussi ce que voit le modèle. L'agent gère l'historique avec des condenseurs et ajoute des compétences et prompts à chaque requête au modèle.
Chaque étape est tracée. L'agent exécute des actions et reçoit des observations, et la conversation conserve cet historique. Le modèle voit ces événements au tour suivant, il sait donc ce qui s'est déjà passé.
Outils et actions
Les outils permettent à l'agent d'agir hors du modèle. Le jeu standard comprend un terminal, un éditeur de fichiers et un suivi de tâches, et vous pouvez en ajouter via des serveurs MCP.
Le modèle demande une action, par exemple « exécuter pytest » ou « remplacer la ligne 8 de budget.py ». L'outil exécute et renvoie une observation, comme la sortie des tests ou le fichier mis à jour.
Avant l'exécution, chaque action passe un contrôle de sécurité. L'analyseur de sécurité évalue l'action et peut mettre l'agent en pause pour approbation.
Environnement de développement
Les outils ne tournent pas sur votre machine : ils s'exécutent dans une sandbox.
Dans la configuration Docker, OpenHands exécute l'agent server dans son propre conteneur. D'où le montage du socket Docker : le conteneur de l'app en a besoin pour démarrer la sandbox.
La sandbox n'a pas besoin d'être locale. Les agents peuvent aussi tourner dans des workspaces éphémères, via Docker ou Kubernetes, et l'Agent Server expose l'exécution, les outils et les espaces via des APIs REST et WebSocket. La logique d'agent reste identique où que tourne la sandbox.
Dépôt
Le dépôt est la matière de l'agent. Il arrive dans la sandbox de deux manières : un dossier local monté, comme dans l'article, ou un dépôt connecté via les intégrations GitHub, GitLab ou Bitbucket.
Un dépôt peut aussi dicter le comportement de l'agent. Un fichier AGENTS.md à la racine est injecté dans l'invite système au début de la conversation. Des consignes plus ciblées vont dans .agents/skills/, où l'agent voit un résumé d'abord et ne charge le contenu complet qu'en cas de besoin.
C'est l'endroit idéal pour les règles que l'agent ne peut pas deviner, du type « lancez les tests avec make test, pas pytest. »
Relecture humaine
Vous êtes la dernière étape de l'architecture.
OpenHands prend en charge trois politiques d'approbation : tout approuver, ne rien approuver, ou n'approuver que les actions risquées. La dernière repose sur l'analyseur de sécurité, qui étiquette chaque action en risque LOW, MEDIUM, HIGH ou UNKNOWN. Par défaut, c'est NeverConfirm : l'agent s'exécute sans s'arrêter, sauf si vous changez ce réglage.
Le second point de contrôle arrive à la fin. Le travail de l'agent n'est achevé qu'après lecture du diff et vérification des tests.
Workflows avec OpenHands
Je vous ai montré une correction en une ligne, mais évidemment OpenHands gère des tâches bien plus vastes.
Le point commun : elles demandent plusieurs étapes. Voici six types de travaux où la boucle agent est pertinente.
Correction de bugs
Le bug de l'article se voyait facilement dans un seul fichier. C'est rarement le cas en production.
Imaginons que les logs applicatifs affichent un KeyError en prod, et que la pile pointe vers une fonction à trois appels de la source des données erronées. Vous collez la stack trace dans OpenHands et demandez une correction.
L'agent remonte la chaîne d'appels jusqu'à la source, écrit un test de reproduction et confirme qu'il échoue. Ensuite, il corrige le code et lance toute la batterie de tests pour s'assurer que rien d'autre n'a cassé.
Le test de reproduction est la clé à rechercher : il prouve que l'agent a trouvé la vraie cause, pas seulement l'endroit où l'erreur se manifeste.
Mise en œuvre de fonctionnalités
Les évolutions touchent souvent plus de fichiers qu'on ne l'imagine.
Supposons qu'un script de rapport en ligne de commande doive accepter un indicateur --since pour filtrer par date. L'agent doit trouver le parseur d'arguments, ajouter le flag, propager la valeur à la logique de filtre, et mettre à jour l'aide. Puis il écrit des tests pour le nouveau comportement et modifie le README.
Cela fait quatre ou cinq fichiers pour une petite fonctionnalité. L'agent les suit dans son tracker, il ne s'arrête pas au premier succès.
Refactoring
Le refactoring vise à changer la structure sans changer le comportement ; la preuve passe par les tests.
Par exemple, un projet a un gros utils.py mélangeant des helpers de dates, de chaînes et de fichiers. Vous demandez à OpenHands de le scinder en trois modules.
L'agent crée les modules, déplace les fonctions et met à jour tous les imports à travers la base. Il lance les tests après chaque déplacement : si ça casse, il sait quelle étape en est la cause.
Écriture de tests
Le code non testé est un point de départ fréquent : la tâche est claire et facile à vérifier.
Imaginons un module de parsing de dates sans tests. L'agent lit les fonctions, écrit des cas pytest pour les cas standards et les bords (chaînes vides, années bissextiles, formats invalides) et les exécute.
Si un nouveau test échoue, l'agent doit décider si le test est faux ou si le code a un bug. C'est une décision à vérifier vous-même.
Exploration de bases de code existantes
Toute tâche ne nécessite pas du code.
Vous pouvez demander à OpenHands : « Où cette app valide-t-elle les entrées utilisateur avant la base ? » L'agent fouille le code, suit les appels inter-fichiers et répond avec des chemins et références de lignes.
Pratique quand vous rejoignez un projet ou reprenez un code laissé depuis des mois. Pour un travail en lecture seule, montez le dépôt en mode :ro au lieu de :rw pour éviter toute modification accidentelle.
Exécution et débogage d'applications
Certains bugs n'apparaissent qu'en exécution.
Supposons qu'un endpoint API renvoie une 500, et que les tests ne la couvrent pas. L'agent démarre le serveur dans son terminal, envoie une requête avec curl et lit la traceback dans les logs.
Ensuite, il corrige le code, redémarre le serveur et renvoie la même requête. Si la réponse est encore mauvaise, la boucle continue.
C'est le même cycle « modifier-exécuter-vérifier » que vous feriez vous-même, sauf que l'agent gère chaque redémarrage et chaque nouvel essai.
OpenHands vs autres agents de codage IA
OpenHands n'est pas le seul outil capable de prendre une tâche et de la mener de bout en bout. Claude Code, Cursor et GitHub Copilot proposent maintenant des fonctions agent, mais avec des différences importantes.
OpenHands vs Claude Code
Ce sont les plus proches. Tous deux exécutent une boucle qui lit le code, édite des fichiers, lance des commandes et vérifie les résultats.
Première différence : la propriété. Chaque dépôt public d'OpenHands a sa licence open source ; vous pouvez tout lire, modifier et auto-héberger. Claude Code est l'outil propriétaire d'Anthropic, disponible au terminal, dans l'IDE, en app desktop et dans le navigateur.
Ce qui mène aux modèles. Claude Code s'articule autour des modèles Claude d'Anthropic. OpenHands fonctionne avec tout fournisseur pris en charge par LiteLLM, y compris une config locale Ollama comme dans l'article.
Le quotidien diffère aussi. Claude Code a démarré au terminal, là où beaucoup de développeurs l'utilisent encore. OpenHands s'appuie sur son interface web, et sa CLI est complète mais maintenue surtout pour la stabilité.
Les deux offrent un contrôle fin. Claude Code lit CLAUDE.md, des réglages, hooks, skills, commandes et sous-agents dans .claude. OpenHands lit AGENTS.md et des skills depuis le dépôt, et le SDK vous permet de construire vos propres agents en Python.
L'autonomie diffère aussi. Claude Code contrôle l'usage d'outils via des modes d'autorisation, hooks et listes d'autorisations/interdictions, et peut isoler les commandes. OpenHands exécute chaque commande dans une sandbox Docker par défaut et ajoute des politiques d'approbation par-dessus.
En résumé, Claude Code est l'option peaufinée à installer et utiliser immédiatement, tandis qu'OpenHands demande plus de configuration et vous rend plus de contrôle. Et ils ne sont pas exclusifs : Agent Canvas peut faire tourner Claude Code à la place de l'agent par défaut.
OpenHands vs Cursor
Cursor est un éditeur de code IA. OpenHands est une plateforme d'agents. C'est la différence fondamentale, dont découlent les autres.
Dans Cursor, vous travaillez dans l'éditeur et l'agent intervient à vos côtés. Vous voyez les édits apparaître, vous les acceptez ou refusez, et vous continuez à coder. Dans OpenHands, vous décrivez une tâche, l'agent travaille dans une sandbox et vous relisez le résultat. L'interface inclut une vue VS Code de la sandbox, mais ce n'est pas là que se joue l'essentiel.
L'accès au dépôt suit le même schéma. L'agent de Cursor agit sur le code ouvert dans votre éditeur. OpenHands travaille sur ce que vous montez dans sa sandbox ou connectez via Git.
L'écart se resserre avec les Cloud Agents de Cursor : ils tournent sans surveillance dans le cloud et renvoient leur travail via branches et pull requests. Ils nécessitent un compte GitHub, GitLab, Azure DevOps ou Bitbucket connecté et un plan payant. C'est proche d'OpenHands, mais sur l'infrastructure de Cursor.
L'extensibilité est la plus grande différence. Cursor prend en charge les serveurs MCP et des règles projet, mais l'éditeur et l'agent restent fermés. Avec OpenHands, vous pouvez modifier l'agent lui-même, l'héberger où vous voulez et l'exécuter sur un modèle local.
OpenHands vs GitHub Copilot
GitHub Copilot a commencé comme outil d'autocomplétion dans l'éditeur, puis a ajouté des fonctionnalités agent. OpenHands est agent dès l'origine.
La grande force de Copilot, c'est son intégration : il fonctionne dans VS Code et les IDE JetBrains, et son agent cloud agit directement sur GitHub. OpenHands n'a pas ce niveau d'intégration IDE.
Pour les tâches au niveau du dépôt, l'agent cloud de Copilot est la meilleure comparaison. Vous lui attribuez un ticket, il travaille dans un environnement éphémère propulsé par GitHub Actions, où il peut lancer tests et linters avant de pousser. OpenHands Cloud fait quelque chose de similaire quand vous mentionnez @openhands dans un commentaire d'issue ou de pull request.
La différence tient surtout à la plateforme. L'agent cloud Copilot est disponible sur tous les plans payants Copilot pour les dépôts GitHub. OpenHands fonctionne avec GitHub, GitLab, Bitbucket ou un dossier local, et peut tourner sur votre propre infrastructure.
Copilot permet de choisir un modèle pour une tâche, mais seulement parmi ceux proposés par GitHub. OpenHands n'a pas cette contrainte.
Voici un récapitulatif rapide :
OpenHands
Claude Code
Cursor
GitHub Copilot
Source
Open source
Propriétaire
Propriétaire
Propriétaire
Modèles
N'importe quel fournisseur LiteLLM, y compris local
Modèles Claude
Plusieurs fournisseurs et modèles internes
Modèles proposés par GitHub
Interface principale
Interface navigateur, SDK
Terminal, IDE, desktop, navigateur
Éditeur de code IA
Extension IDE, GitHub
Où tourne l'agent
Sandbox Docker, locale ou distante
Votre machine ou le cloud d'Anthropic
Votre éditeur ou le cloud de Cursor
Votre IDE ou GitHub Actions
Auto-hébergement
Oui
Non
Entreprise uniquement
Non
OpenHands comparé à d'autres agents IA
OpenHands pour les équipes d'ingénierie logicielle
Pour un développeur seul, OpenHands est un outil qu'on ouvre à la demande. En équipe, c'est différent.
La plupart des équipes s'organisent déjà autour d'issues, et OpenHands Cloud s'y intègre. Il se connecte à GitHub, GitLab et Bitbucket, ainsi qu'à Slack, Jira et Linear. Vous pouvez mentionner @openhands dans une issue ou un commentaire de pull request : l'agent prend la tâche à partir de là.
Il y a aussi le travail que personne ne demande mais que tout le monde attend. Les automatisations d'Agent Canvas tournent à intervalles réguliers ou via webhooks. Par exemple, une équipe peut partager un Agent Server pour la revue de code et les mises à jour de dépendances, pendant que chaque développeur fait tourner des agents personnels sur son laptop.
Les tests se gèrent comme dans l'article. L'agent exécute la batterie dans sa sandbox avant de rendre compte. Mais cette exécution ne remplace pas la CI : votre pipeline tourne toujours sur chaque pull request, comme pour du code écrit par un humain.
Les pull requests sont un autre sujet. Avec GitHub, OpenHands Cloud demande des jetons à durée de vie courte (8 heures), avec droits de lecture/écriture sur contenus, issues, PR et workflows. En auto-hébergement Enterprise, l'agent utilise l'autorisation GitHub de l'utilisateur qui l'a déclenché : chaque changement est traçable à une personne.
C'est ainsi que la responsabilité doit fonctionner : l'agent ouvre la PR, mais un développeur l'approuve. La protection de branche et les revues obligatoires s'appliquent à ses PR comme aux autres.
Des environnements isolés permettent de passer à l'échelle : chaque tâche tourne dans sa sandbox, deux agents corrigeant deux bugs ne s'écrasent pas mutuellement ni ne se disputent un port.
Sécurité et sandboxing d'OpenHands
Un outil d'autocomplétion propose du texte, à vous de l'accepter.
Un agent, c'est différent. Il parcourt votre projet, exécute des commandes, installe des paquets et modifie des fichiers de lui-même, souvent sans demander. La question devient : « qu'a-t-il exécuté pour en arriver là ? »
Environnements d'exécution isolés
La sandbox Docker protège vos fichiers et programmes hôtes, les ressources et les autres conteneurs/processus. Si l'agent lance une commande destructrice, son effet reste confiné au conteneur.
Une exception en local : le conteneur applicatif monte le socket Docker de l'hôte pour démarrer les sandboxes, et l'accès à ce socket signifie le contrôle de Docker sur votre machine.
Permissions sur le dépôt
La sandbox ne protège pas ce que vous montez. Les fichiers et répertoires montés peuvent être modifiés ou supprimés.
Ne montez que le projet en cours, jamais votre dossier personnel. Pour l'analyse en lecture seule, utilisez le mode :ro. Avec les intégrations Git, donnez à l'agent l'accès aux seuls dépôts nécessaires.
Secrets et identifiants
Si vous fournissez des identifiants (clés API, tokens), l'agent peut les utiliser. Et un agent qui lit un secret peut également l'imprimer dans les logs ou l'envoyer ailleurs.
Nemontez donc pas de dossiers contenant des fichiers .env avec des clés de production. Donnez à l'agent des identifiants de test à portée limitée et faites-les tourner fréquemment.
Accès réseau
Par défaut, l'agent peut accéder à Internet depuis le conteneur. Il en a besoin pour installer des paquets, mais peut aussi joindre des services externes.
Cela ouvre la porte à l'injection d'invite. Une page web ou un commentaire d'issue peut contenir des instructions que l'agent suivra peut-être. GitHub réduit ce risque pour son agent cloud avec un pare-feu qui limite l'accès Internet par défaut ; envisagez le même type de restriction pour votre configuration OpenHands.
Exécution de commandes
Vous pouvez contrôler quelles commandes s'exécutent sans approbation. OpenHands propose trois politiques d'approbation : tout approuver, rien approuver, ou seulement les actions risquées. Par défaut : NeverConfirm.
Attention avec l'option « actions risquées » : l'analyseur de sécurité LLM par défaut s'appuie sur le niveau de risque que le modèle attribue à ses propres actions. Un modèle peut marquer une commande destructrice en LOW, qui s'exécutera sans vous demander. L'analyseur classe le risque pour la politique – il ne bloque rien en soi. La doc recommande de le combiner avec l'isolation Docker.
Relecture des modifications générées
Tout ce qui précède limite ce que l'agent peut faire. Mais la relecture reste cruciale : c'est ainsi que vous contrôlez ce qu'il a fait.
Lisez le diff complet, pas seulement les fichiers attendus. Soyez attentif à la configuration CI, aux dépendances et aux scripts. Dans OpenHands Cloud, le token GitHub de l'agent inclut l'écriture sur les workflows : une modification dans .github/workflows peut changer ce qui s'exécute dans votre pipeline.
Limites d'OpenHands
Le code généré par OpenHands peut encore contenir des bugs. Des tests au vert signifient seulement que le code correspond aux tests, que l'agent peut aussi écrire. Si les tests sont faibles, le code peut passer tout en étant faux.
Les tâches complexes nécessitent souvent votre intervention. Des besoins flous ou une décision de conception que l'agent ne peut pas prendre le bloqueront ou, pire, l'enverront dans la mauvaise direction.
Avec un modèle hébergé performant, OpenHands gère bien les tâches multi-fichiers. Avec un petit modèle local, vous verrez des appels d'outils ratés et des réponses de type chatbot, et même avec une grande fenêtre de contexte, certains modèles locaux utilisent mal les outils.
Les boucles agent coûtent aussi plus cher que le chat. Chaque étape renvoie l'historique au modèle, et les longues tâches accumulent les étapes. La doc OpenHands prévient que l'agent envoie de nombreuses invites au LLM et recommande des plafonds de dépenses et un suivi d'usage. Le condenseur de contexte aide, mais il résume les étapes anciennes : des détails se perdent sur la durée.
L'accès aux outils ajoute un risque sécurité. Un agent avec un terminal et un réseau peut causer de vrais dégâts s'il suit de mauvaises instructions : d'où l'importance de la sandbox et de votre relecture.
Et chaque changement demande encore une approbation humaine. Gardez-le en tête.
OpenHands et l'avenir des agents de codage IA
Les outils de codage IA ont évolué de l'autocomplétion au chat, puis aux agents qui mènent une tâche entière. OpenHands fait partie des projets qui poussent cette étape.
La direction est claire dans l'industrie. Cursor décrit une ère émergente où des agents cloud autonomes prennent des tâches plus larges sur des durées plus longues. Copilot prend maintenant des issues depuis GitHub et Linear. Claude Code fonctionne dans le terminal, le navigateur et Slack.
Les plateformes open source ont un rôle spécifique dans ce mouvement. Avec OpenHands, vous pouvez inspecter le fonctionnement de l'agent, l'exécuter sur votre infrastructure et choisir le modèle. Pour des équipes aux règles de données strictes, c'est souvent la seule voie autorisée.
Les tâches longues amènent aussi de nouveaux défis. Un agent qui travaille une heure prend bien plus de décisions qu'en une minute, et chaque décision peut l'éloigner de l'objectif. De meilleurs modèles aident, tout comme les sandboxes, politiques d'approbation et relectures.
Conclusion
Ce qui distingue OpenHands de ses concurrents, c'est le contrôle. Vous pouvez lire le code source, l'héberger sur votre propre matériel et l'exécuter avec n'importe quel modèle, y compris local. Des outils commerciaux plus fermés comme Claude Code, Cursor et GitHub Copilot offrent une expérience plus polie, mais à leurs conditions.
Mais un agent avec accès à votre terminal et à vos dépôts a toujours besoin d'une relecture humaine. Pensez à lire le diff et à lancer les tests vous-même.
Scientifique de données senior basé en Croatie. Rédacteur technique de premier plan avec plus de 700 articles publiés, générant plus de 10 millions de vues. Auteur du livre Machine Learning Automation with TPOT.
FAQs
Qu'est-ce qu'OpenHands ?⌄
OpenHands est une plateforme open source pour créer et exécuter des agents IA qui travaillent avec du code. Son agent de codage peut inspecter un dépôt, éditer des fichiers, lancer des commandes et des tests, puis itérer sur les résultats jusqu'à ce que la tâche soit terminée. Vous pouvez l'exécuter en local via Docker, via le SDK, ou sur OpenHands Cloud.
OpenHands est-il gratuit ?⌄
Le logiciel OpenHands est open source, vous pouvez donc l'auto-héberger sans payer de licence. Ce que vous payez, c'est le modèle : des fournisseurs hébergés comme Anthropic ou OpenAI facturent au token, et les boucles agent en consomment beaucoup. Si vous utilisez un modèle local via Ollama ou LM Studio, le seul coût est votre matériel. OpenHands Cloud est un service commercial distinct.
En quoi OpenHands diffère-t-il de GitHub Copilot ou Cursor ?⌄
Copilot et Cursor sont conçus autour de l'éditeur, où l'IA travaille à vos côtés pendant que vous codez. OpenHands est agent-first : vous décrivez une tâche, l'agent la réalise dans une sandbox et vous relisez le résultat. Il est aussi open source, fonctionne avec n'importe quel modèle pris en charge par LiteLLM et tourne sur votre propre infrastructure — ce que ni Copilot ni Cursor ne proposent au même degré.
Puis-je faire tourner OpenHands avec un modèle local ?⌄
Oui. OpenHands se connecte à des serveurs locaux comme LM Studio, Ollama, vLLM et SGLang via leurs APIs compatibles OpenAI. Choisissez un modèle conçu pour le codage agentique, comme Devstral Small 2 ou Qwen3.6-35B-A3B, et réglez la fenêtre de contexte à au moins 22000 tokens. Les petits modèles généralistes échouent souvent sur les appels d'outils et répondent comme un chatbot.
Est-il sûr de donner accès à mon code ?⌄
OpenHands exécute les commandes de l'agent dans une sandbox Docker, ce qui protège votre système hôte de la plupart des erreurs. Mais tout ce que vous montez dans la sandbox peut être modifié ou supprimé, et tout identifiant fourni peut être utilisé par l'agent. Par défaut, l'agent n'attend pas d'approbation avant d'agir : ne montez que le projet nécessaire, utilisez des identifiants de test limités et relisez chaque diff avant de fusionner.
Découvrez les principaux types d'agents d'intelligence artificielle, comment ils interagissent avec les environnements et comment ils sont utilisés dans les différents secteurs d'activité. Comprendre les agents réflexes simples, les agents basés sur un modèle, les agents basés sur un but, les agents basés sur l'utilité, les agents d'apprentissage, etc.
Apprenez l'essentiel de l'architecture d'un entrepôt de données, des composants clés aux meilleures pratiques, pour construire un système de données évolutif et efficace !
L'essor du développement de l'intelligence artificielle (IA) a entraîné une augmentation notable de la demande en matière de calcul, d'où la nécessité de disposer de solutions matérielles robustes. Les unités de traitement graphique (GPU) et les unités de traitement tensoriel (TPU) sont devenues des technologies essentielles pour répondre à ces demandes.
OpenHands est une plateforme open source pour le développement logiciel augmenté par l'IA, centrée sur un agent capable d'inspecter votre dépôt, d'éditer des fichiers, d'exécuter des commandes et de lancer des tests. Elle s'inscrit dans la tendance du développement logiciel agentique : vous confiez une tâche complète à l'agent, qui l'exécute pas à pas jusqu'à résolution ou besoin de votre avis.
Dans cet article, je vous présente l'architecture d'OpenHands et ses fonctionnalités phares, je vous montre comment le configurer avec un modèle local, puis je le compare à Claude Code, Cursor et GitHub Copilot.
Qu'est-ce qu'un agent IA ? Inscrivez-vous à notre parcours AI Agent Fundamentals pour découvrir comment les agents d'IA peuvent transformer votre façon de travailler.
Qu'est-ce qu'OpenHands ?
OpenHands est une plateforme open source pour créer et exécuter des agents IA spécialisés sur le code.
Le nom recouvre deux réalités : d'abord le projet, un ensemble de dépôts avec un SDK, un serveur, une interface web et un service hébergé ; ensuite l'agent de codage qui s'exécute par-dessus.
Voici le fonctionnement :
Quand on dit « OpenHands », on parle généralement de l'agent. C'est celui que j'utilise ici.
Le plus souvent, vous lui donnez une tâche logicielle, vous le pointez vers un espace de travail contenant votre code, et il avance avec ses outils. Par défaut : un terminal, un éditeur de fichiers et un suivi de tâches.
L'espace de travail n'a pas besoin d'être votre machine. Les agents peuvent utiliser la machine locale ou s'exécuter dans des workspaces éphémères, par exemple via Docker ou Kubernetes.
OpenHands ne vous enferme pas non plus chez un fournisseur de modèles. Vous pouvez l'utiliser avec Claude, GPT ou tout autre LLM, y compris des modèles locaux. Agent Canvas peut même exécuter des agents tiers comme Claude Code et Codex à la place de l'agent OpenHands par défaut.
En bref, OpenHands est une plateforme d'agents ouverte que vous pouvez opérer selon vos propres règles.
Comment fonctionne OpenHands
OpenHands fonctionne en boucle.
Un assistant de chat reçoit votre invite et répond en texte. L'agent OpenHands, lui, reçoit une tâche, passe à l'action, observe le résultat et décide de la suite.
La boucle de l'agent OpenHands
L'idée générale :
La boucle s'arrête quand la tâche est terminée, ou si l'agent a besoin de quelque chose que vous seul pouvez fournir, comme un identifiant manquant ou une décision sur le besoin.
L'étape 6 différencie OpenHands de la concurrence. Un outil d'autocomplétion ne voit jamais ce qui se passe quand son code s'exécute. OpenHands, si : il peut réagir à un test échoué et corriger la cause.
Fonctionnalités clé d'OpenHands
L'autocomplétion suggère du texte, OpenHands agit sur votre projet. Voici comment.
Édition de code
OpenHands modifie directement les fichiers, et n'est pas limité à un seul fichier à la fois.
Supposons qu'une fonction doive être renommée. L'agent met à jour sa définition, retrouve tous les appels et met à jour les tests qui y font référence – le tout dans une même tâche.
Terminal et usage d'outils
L'agent possède son propre terminal. Il peut installer des dépendances, exécuter des scripts, lancer des tests et lire la sortie de n'importe quelle commande.
Vous pouvez aussi connecter des serveurs MCP (Model Context Protocol) pour lui offrir des outils non prévus initialement, comme un traqueur d'anomalies ou un client base de données.
Compréhension du dépôt
La plupart des générateurs de code ne voient que ce que vous collez dans l'invite.
OpenHands ouvre le dépôt et l'explore. Il peut lire le README, suivre les imports et consulter les tests existants pour comprendre la structure du projet. Résultat : ses modifications ont davantage de chances de s'intégrer harmonieusement au code en place.
Les tâches longues posent un autre problème : l'historique de conversation dépasse la capacité du modèle. OpenHands gère cela avec un « condenseur de contexte » qui résume les parties anciennes pour permettre à l'agent de poursuivre.
Choix du modèle
Les appels modèle passent par LiteLLM, vous pouvez donc utiliser tout fournisseur et modèle pris en charge. La doc OpenHands recommande des modèles des familles Claude, GPT et Gemini, ainsi que des modèles open-weight bien classés dans l'OpenHands Index.
Si votre code ne peut pas quitter votre machine, exécutez un modèle local. OpenHands se connecte à des serveurs locaux comme LM Studio, Ollama, vLLM et SGLang.
Gardez en tête que le modèle influe fortement sur le résultat. Certains modèles locaux peinent à utiliser les outils de manière fiable, même avec une grande fenêtre de contexte.
Exécution autonome des tâches
Une fois la tâche déléguée, l'agent enchaîne la boucle tout seul. Pas besoin de recoller les erreurs dans un chat ni d'indiquer quel fichier ouvrir ensuite.
Agent Canvas va plus loin avec des automatisations. Elles s'intègrent à Slack, GitHub, Linear, etc., et se déclenchent selon un horaire ou via des webhooks.
Mais l'autonomie ne garantit pas la justesse. Vous devez toujours relire le diff et les résultats de tests avant toute fusion.
Comment utiliser OpenHands
Le meilleur moyen de comprendre OpenHands est de lui confier un bug et d'observer.
Dans cette section, j'exécute OpenHands en local avec Docker, je le connecte à un modèle local via Ollama et je lui demande de corriger un bug dans un petit projet Python.
Configurer OpenHands
Vous pouvez lancer OpenHands de plusieurs façons :
Lanceur CLI : installez-le avec
uv tool install openhands --python 3.14, puis démarrez l'interface graphique avecopenhands serveDocker : lancez directement le conteneur de l'application avec une seule commande
docker runAgent Canvas : le nouveau client web qui se connecte à des backends locaux, auto-hébergés, Cloud ou Enterprise
OpenHands Cloud : la version hébergée si vous préférez ne rien opérer vous-même
Je vais utiliser la voie Docker avec l'interface locale. La documentation OpenHands la mentionne désormais comme application web Docker dépréciée et oriente vers Agent Canvas pour la remplacer, mais elle reste documentée et c'est le moyen le plus rapide d'obtenir une interface.
Vous aurez besoin de Docker Desktop sur macOS, Linux ou Windows avec WSL. Sur macOS, ouvrez Docker Desktop, allez dans
Settings > Advancedet activez le socket Docker par défaut.Démarrez ensuite l'application :
OpenHands utilise le montage du socket Docker pour démarrer un conteneur de sandbox séparé, et l'agent exécute ses commandes dans cette sandbox, pas sur votre hôte.
Une fois que les journaux indiquent que le serveur est en ligne, ouvrez
http://localhost:3000dans votre navigateur.Page d'accueil d'OpenHands
Connecter un modèle
OpenHands ne fera rien tant que vous ne lui aurez pas fourni un modèle.
J'utilise Devstral Small 2, le modèle 24B de Mistral conçu pour le codage agentique. Il est assez léger pour tourner sur une seule RTX 4090 ou un Mac avec 32 Go de RAM. Il nécessite Ollama 0.13.3 ou version ultérieure.
Démarrez Ollama avec une fenêtre de contexte plus grande et récupérez le modèle :
Ne sous-estimez pas la longueur du contexte. La valeur par défaut d'Ollama est 4096 tokens, trop faible pour tenir même l'invite système d'OpenHands. La doc recommande au moins 22000.
Dans OpenHands, ouvrez
Settings, allez dans l'ongletLLMet activezAdvanced. Puis renseignez :Custom Model :
openai/devstral-small-2:latestBase URL :
http://host.docker.internal:11434/v1API Key : n'importe quelle valeur factice, par exemple
local-llmParamètres LLM pour un modèle Ollama local
Le préfixe
openai/indique à OpenHands de parler à Ollama via son API compatible OpenAI. La clé API n'est pas utilisée, mais le champ ne peut pas être vide.Ouvrir un dépôt
Par défaut, OpenHands ne voit pas vos fichiers. Vous devez monter le projet dans la sandbox.
Pour cet exemple, préparez un dossier
budget-tracker/projectavec deux fichiers. Le premier agrège les dépenses par mois :La docstring promet des clés au format
YYYY-MM, maisdate[5:7]ne garde que le mois. Janvier 2025 et janvier 2026 finiront dans le même agrégat.Le second fichier contient deux tests qui détectent le bug :
Initialisez le dossier en dépôt Git pour visualiser ensuite les changements de l'agent :
Si vous lancez
python -m pytestmaintenant, les deux tests échouent :Tests en échec
Pour donner l'accès à OpenHands, arrêtez le conteneur et ajoutez une ligne à la commande
docker run:La commande complète devient :
Le format est
host_path:container_path:mode. Votre projet apparaît dans la sandbox sous/workspace, etrwautorise l'agent à le modifier.Ne montez que le projet que vous souhaitez voir modifier. Tout ce qui est monté en lecture-écriture dans
/workspacepeut être altéré par l'agent.Donner une tâche à l'agent
Démarrez une nouvelle conversation et décrivez le problème comme dans un ticket :
Les totaux mensuels fusionnent les dépenses du même mois sur différentes années.
Trouvez la cause, corrigez-la et exécutez les tests pour confirmer qu'ils passent.
C'est tout. Inutile d'indiquer
budget.pyni de désigner la ligne fautive.Sortie de conversation
La boucle agent vue plus haut prend le relais. L'agent explore
/workspace, lit les deux fichiers et lance les tests pour voir ce qui échoue. Puis il édite le code et relance les tests.L'agent exécute pytest dans le terminal de la sandbox
Passer en revue les changements
L'agent indique qu'il a terminé. Vous pouvez maintenant afficher les différences en ouvrant l'éditeur de code et en inspectant les modifications.
La correction exacte tient en une ligne dans
budget.py:budget.py corrigé
Vous pouvez également lancer un
git diffpour voir les différences.Vérifiez en particulier :
Le code source : la correction doit être dans
budget.pyLes tests : assurez-vous que l'agent n'a pas édité
test_budget.pyjuste pour faire passer les assertionsL'exécution des tests : lancez
python -m pytestvous-même : ne vous contentez pas du résumé de l'agentArchitecture d'OpenHands
OpenHands se compose de six briques principales, chacune avec une responsabilité claire.
Comment les composants OpenHands s'articulent
Modèle IA
Le modèle fait le raisonnement. Il reçoit la tâche et l'historique de conversation, et répond par un message ou un appel d'outil.
Le modèle ne modifie pas vos fichiers et n'exécute rien. Il décide seulement de la prochaine action. Les appels passent par LiteLLM, ainsi le même agent fonctionne avec un fournisseur hébergé ou un modèle local comme la configuration Devstral de l'article.
Logique d'agent
L'agent fait l'interface entre le modèle et le reste. Il exécute la boucle « raisonnement-action » : il demande au modèle l'action suivante, appelle l'outil, et gère le résultat ou l'erreur.
Il choisit aussi ce que voit le modèle. L'agent gère l'historique avec des condenseurs et ajoute des compétences et prompts à chaque requête au modèle.
Chaque étape est tracée. L'agent exécute des actions et reçoit des observations, et la conversation conserve cet historique. Le modèle voit ces événements au tour suivant, il sait donc ce qui s'est déjà passé.
Outils et actions
Les outils permettent à l'agent d'agir hors du modèle. Le jeu standard comprend un terminal, un éditeur de fichiers et un suivi de tâches, et vous pouvez en ajouter via des serveurs MCP.
Le modèle demande une action, par exemple « exécuter
pytest» ou « remplacer la ligne 8 debudget.py». L'outil exécute et renvoie une observation, comme la sortie des tests ou le fichier mis à jour.Avant l'exécution, chaque action passe un contrôle de sécurité. L'analyseur de sécurité évalue l'action et peut mettre l'agent en pause pour approbation.
Environnement de développement
Les outils ne tournent pas sur votre machine : ils s'exécutent dans une sandbox.
Dans la configuration Docker, OpenHands exécute l'agent server dans son propre conteneur. D'où le montage du socket Docker : le conteneur de l'app en a besoin pour démarrer la sandbox.
La sandbox n'a pas besoin d'être locale. Les agents peuvent aussi tourner dans des workspaces éphémères, via Docker ou Kubernetes, et l'Agent Server expose l'exécution, les outils et les espaces via des APIs REST et WebSocket. La logique d'agent reste identique où que tourne la sandbox.
Dépôt
Le dépôt est la matière de l'agent. Il arrive dans la sandbox de deux manières : un dossier local monté, comme dans l'article, ou un dépôt connecté via les intégrations GitHub, GitLab ou Bitbucket.
Un dépôt peut aussi dicter le comportement de l'agent. Un fichier
AGENTS.mdà la racine est injecté dans l'invite système au début de la conversation. Des consignes plus ciblées vont dans.agents/skills/, où l'agent voit un résumé d'abord et ne charge le contenu complet qu'en cas de besoin.C'est l'endroit idéal pour les règles que l'agent ne peut pas deviner, du type « lancez les tests avec
make test, paspytest. »Relecture humaine
Vous êtes la dernière étape de l'architecture.
OpenHands prend en charge trois politiques d'approbation : tout approuver, ne rien approuver, ou n'approuver que les actions risquées. La dernière repose sur l'analyseur de sécurité, qui étiquette chaque action en risque LOW, MEDIUM, HIGH ou UNKNOWN. Par défaut, c'est NeverConfirm : l'agent s'exécute sans s'arrêter, sauf si vous changez ce réglage.
Le second point de contrôle arrive à la fin. Le travail de l'agent n'est achevé qu'après lecture du diff et vérification des tests.
Workflows avec OpenHands
Je vous ai montré une correction en une ligne, mais évidemment OpenHands gère des tâches bien plus vastes.
Le point commun : elles demandent plusieurs étapes. Voici six types de travaux où la boucle agent est pertinente.
Correction de bugs
Le bug de l'article se voyait facilement dans un seul fichier. C'est rarement le cas en production.
Imaginons que les logs applicatifs affichent un
KeyErroren prod, et que la pile pointe vers une fonction à trois appels de la source des données erronées. Vous collez la stack trace dans OpenHands et demandez une correction.L'agent remonte la chaîne d'appels jusqu'à la source, écrit un test de reproduction et confirme qu'il échoue. Ensuite, il corrige le code et lance toute la batterie de tests pour s'assurer que rien d'autre n'a cassé.
Le test de reproduction est la clé à rechercher : il prouve que l'agent a trouvé la vraie cause, pas seulement l'endroit où l'erreur se manifeste.
Mise en œuvre de fonctionnalités
Les évolutions touchent souvent plus de fichiers qu'on ne l'imagine.
Supposons qu'un script de rapport en ligne de commande doive accepter un indicateur
--sincepour filtrer par date. L'agent doit trouver le parseur d'arguments, ajouter le flag, propager la valeur à la logique de filtre, et mettre à jour l'aide. Puis il écrit des tests pour le nouveau comportement et modifie le README.Cela fait quatre ou cinq fichiers pour une petite fonctionnalité. L'agent les suit dans son tracker, il ne s'arrête pas au premier succès.
Refactoring
Le refactoring vise à changer la structure sans changer le comportement ; la preuve passe par les tests.
Par exemple, un projet a un gros
utils.pymélangeant des helpers de dates, de chaînes et de fichiers. Vous demandez à OpenHands de le scinder en trois modules.L'agent crée les modules, déplace les fonctions et met à jour tous les imports à travers la base. Il lance les tests après chaque déplacement : si ça casse, il sait quelle étape en est la cause.
Écriture de tests
Le code non testé est un point de départ fréquent : la tâche est claire et facile à vérifier.
Imaginons un module de parsing de dates sans tests. L'agent lit les fonctions, écrit des cas pytest pour les cas standards et les bords (chaînes vides, années bissextiles, formats invalides) et les exécute.
Si un nouveau test échoue, l'agent doit décider si le test est faux ou si le code a un bug. C'est une décision à vérifier vous-même.
Exploration de bases de code existantes
Toute tâche ne nécessite pas du code.
Vous pouvez demander à OpenHands : « Où cette app valide-t-elle les entrées utilisateur avant la base ? » L'agent fouille le code, suit les appels inter-fichiers et répond avec des chemins et références de lignes.
Pratique quand vous rejoignez un projet ou reprenez un code laissé depuis des mois. Pour un travail en lecture seule, montez le dépôt en mode
:roau lieu de:rwpour éviter toute modification accidentelle.Exécution et débogage d'applications
Certains bugs n'apparaissent qu'en exécution.
Supposons qu'un endpoint API renvoie une 500, et que les tests ne la couvrent pas. L'agent démarre le serveur dans son terminal, envoie une requête avec
curlet lit la traceback dans les logs.Ensuite, il corrige le code, redémarre le serveur et renvoie la même requête. Si la réponse est encore mauvaise, la boucle continue.
C'est le même cycle « modifier-exécuter-vérifier » que vous feriez vous-même, sauf que l'agent gère chaque redémarrage et chaque nouvel essai.
OpenHands vs autres agents de codage IA
OpenHands n'est pas le seul outil capable de prendre une tâche et de la mener de bout en bout. Claude Code, Cursor et GitHub Copilot proposent maintenant des fonctions agent, mais avec des différences importantes.
OpenHands vs Claude Code
Ce sont les plus proches. Tous deux exécutent une boucle qui lit le code, édite des fichiers, lance des commandes et vérifie les résultats.
Première différence : la propriété. Chaque dépôt public d'OpenHands a sa licence open source ; vous pouvez tout lire, modifier et auto-héberger. Claude Code est l'outil propriétaire d'Anthropic, disponible au terminal, dans l'IDE, en app desktop et dans le navigateur.
Ce qui mène aux modèles. Claude Code s'articule autour des modèles Claude d'Anthropic. OpenHands fonctionne avec tout fournisseur pris en charge par LiteLLM, y compris une config locale Ollama comme dans l'article.
Le quotidien diffère aussi. Claude Code a démarré au terminal, là où beaucoup de développeurs l'utilisent encore. OpenHands s'appuie sur son interface web, et sa CLI est complète mais maintenue surtout pour la stabilité.
Les deux offrent un contrôle fin. Claude Code lit
CLAUDE.md, des réglages, hooks, skills, commandes et sous-agents dans.claude. OpenHands litAGENTS.mdet des skills depuis le dépôt, et le SDK vous permet de construire vos propres agents en Python.L'autonomie diffère aussi. Claude Code contrôle l'usage d'outils via des modes d'autorisation, hooks et listes d'autorisations/interdictions, et peut isoler les commandes. OpenHands exécute chaque commande dans une sandbox Docker par défaut et ajoute des politiques d'approbation par-dessus.
En résumé, Claude Code est l'option peaufinée à installer et utiliser immédiatement, tandis qu'OpenHands demande plus de configuration et vous rend plus de contrôle. Et ils ne sont pas exclusifs : Agent Canvas peut faire tourner Claude Code à la place de l'agent par défaut.
OpenHands vs Cursor
Cursor est un éditeur de code IA. OpenHands est une plateforme d'agents. C'est la différence fondamentale, dont découlent les autres.
Dans Cursor, vous travaillez dans l'éditeur et l'agent intervient à vos côtés. Vous voyez les édits apparaître, vous les acceptez ou refusez, et vous continuez à coder. Dans OpenHands, vous décrivez une tâche, l'agent travaille dans une sandbox et vous relisez le résultat. L'interface inclut une vue VS Code de la sandbox, mais ce n'est pas là que se joue l'essentiel.
L'accès au dépôt suit le même schéma. L'agent de Cursor agit sur le code ouvert dans votre éditeur. OpenHands travaille sur ce que vous montez dans sa sandbox ou connectez via Git.
L'écart se resserre avec les Cloud Agents de Cursor : ils tournent sans surveillance dans le cloud et renvoient leur travail via branches et pull requests. Ils nécessitent un compte GitHub, GitLab, Azure DevOps ou Bitbucket connecté et un plan payant. C'est proche d'OpenHands, mais sur l'infrastructure de Cursor.
L'extensibilité est la plus grande différence. Cursor prend en charge les serveurs MCP et des règles projet, mais l'éditeur et l'agent restent fermés. Avec OpenHands, vous pouvez modifier l'agent lui-même, l'héberger où vous voulez et l'exécuter sur un modèle local.
OpenHands vs GitHub Copilot
GitHub Copilot a commencé comme outil d'autocomplétion dans l'éditeur, puis a ajouté des fonctionnalités agent. OpenHands est agent dès l'origine.
La grande force de Copilot, c'est son intégration : il fonctionne dans VS Code et les IDE JetBrains, et son agent cloud agit directement sur GitHub. OpenHands n'a pas ce niveau d'intégration IDE.
Pour les tâches au niveau du dépôt, l'agent cloud de Copilot est la meilleure comparaison. Vous lui attribuez un ticket, il travaille dans un environnement éphémère propulsé par GitHub Actions, où il peut lancer tests et linters avant de pousser. OpenHands Cloud fait quelque chose de similaire quand vous mentionnez
@openhandsdans un commentaire d'issue ou de pull request.La différence tient surtout à la plateforme. L'agent cloud Copilot est disponible sur tous les plans payants Copilot pour les dépôts GitHub. OpenHands fonctionne avec GitHub, GitLab, Bitbucket ou un dossier local, et peut tourner sur votre propre infrastructure.
Copilot permet de choisir un modèle pour une tâche, mais seulement parmi ceux proposés par GitHub. OpenHands n'a pas cette contrainte.
Voici un récapitulatif rapide :
OpenHands comparé à d'autres agents IA
OpenHands pour les équipes d'ingénierie logicielle
Pour un développeur seul, OpenHands est un outil qu'on ouvre à la demande. En équipe, c'est différent.
La plupart des équipes s'organisent déjà autour d'issues, et OpenHands Cloud s'y intègre. Il se connecte à GitHub, GitLab et Bitbucket, ainsi qu'à Slack, Jira et Linear. Vous pouvez mentionner
@openhandsdans une issue ou un commentaire de pull request : l'agent prend la tâche à partir de là.Il y a aussi le travail que personne ne demande mais que tout le monde attend. Les automatisations d'Agent Canvas tournent à intervalles réguliers ou via webhooks. Par exemple, une équipe peut partager un Agent Server pour la revue de code et les mises à jour de dépendances, pendant que chaque développeur fait tourner des agents personnels sur son laptop.
Les tests se gèrent comme dans l'article. L'agent exécute la batterie dans sa sandbox avant de rendre compte. Mais cette exécution ne remplace pas la CI : votre pipeline tourne toujours sur chaque pull request, comme pour du code écrit par un humain.
Les pull requests sont un autre sujet. Avec GitHub, OpenHands Cloud demande des jetons à durée de vie courte (8 heures), avec droits de lecture/écriture sur contenus, issues, PR et workflows. En auto-hébergement Enterprise, l'agent utilise l'autorisation GitHub de l'utilisateur qui l'a déclenché : chaque changement est traçable à une personne.
C'est ainsi que la responsabilité doit fonctionner : l'agent ouvre la PR, mais un développeur l'approuve. La protection de branche et les revues obligatoires s'appliquent à ses PR comme aux autres.
Des environnements isolés permettent de passer à l'échelle : chaque tâche tourne dans sa sandbox, deux agents corrigeant deux bugs ne s'écrasent pas mutuellement ni ne se disputent un port.
Sécurité et sandboxing d'OpenHands
Un outil d'autocomplétion propose du texte, à vous de l'accepter.
Un agent, c'est différent. Il parcourt votre projet, exécute des commandes, installe des paquets et modifie des fichiers de lui-même, souvent sans demander. La question devient : « qu'a-t-il exécuté pour en arriver là ? »
Environnements d'exécution isolés
La sandbox Docker protège vos fichiers et programmes hôtes, les ressources et les autres conteneurs/processus. Si l'agent lance une commande destructrice, son effet reste confiné au conteneur.
Une exception en local : le conteneur applicatif monte le socket Docker de l'hôte pour démarrer les sandboxes, et l'accès à ce socket signifie le contrôle de Docker sur votre machine.
Permissions sur le dépôt
La sandbox ne protège pas ce que vous montez. Les fichiers et répertoires montés peuvent être modifiés ou supprimés.
Ne montez que le projet en cours, jamais votre dossier personnel. Pour l'analyse en lecture seule, utilisez le mode
:ro. Avec les intégrations Git, donnez à l'agent l'accès aux seuls dépôts nécessaires.Secrets et identifiants
Si vous fournissez des identifiants (clés API, tokens), l'agent peut les utiliser. Et un agent qui lit un secret peut également l'imprimer dans les logs ou l'envoyer ailleurs.
Nemontez donc pas de dossiers contenant des fichiers
.envavec des clés de production. Donnez à l'agent des identifiants de test à portée limitée et faites-les tourner fréquemment.Accès réseau
Par défaut, l'agent peut accéder à Internet depuis le conteneur. Il en a besoin pour installer des paquets, mais peut aussi joindre des services externes.
Cela ouvre la porte à l'injection d'invite. Une page web ou un commentaire d'issue peut contenir des instructions que l'agent suivra peut-être. GitHub réduit ce risque pour son agent cloud avec un pare-feu qui limite l'accès Internet par défaut ; envisagez le même type de restriction pour votre configuration OpenHands.
Exécution de commandes
Vous pouvez contrôler quelles commandes s'exécutent sans approbation. OpenHands propose trois politiques d'approbation : tout approuver, rien approuver, ou seulement les actions risquées. Par défaut : NeverConfirm.
Attention avec l'option « actions risquées » : l'analyseur de sécurité LLM par défaut s'appuie sur le niveau de risque que le modèle attribue à ses propres actions. Un modèle peut marquer une commande destructrice en LOW, qui s'exécutera sans vous demander. L'analyseur classe le risque pour la politique – il ne bloque rien en soi. La doc recommande de le combiner avec l'isolation Docker.
Relecture des modifications générées
Tout ce qui précède limite ce que l'agent peut faire. Mais la relecture reste cruciale : c'est ainsi que vous contrôlez ce qu'il a fait.
Lisez le diff complet, pas seulement les fichiers attendus. Soyez attentif à la configuration CI, aux dépendances et aux scripts. Dans OpenHands Cloud, le token GitHub de l'agent inclut l'écriture sur les workflows : une modification dans
.github/workflowspeut changer ce qui s'exécute dans votre pipeline.Limites d'OpenHands
Le code généré par OpenHands peut encore contenir des bugs. Des tests au vert signifient seulement que le code correspond aux tests, que l'agent peut aussi écrire. Si les tests sont faibles, le code peut passer tout en étant faux.
Les tâches complexes nécessitent souvent votre intervention. Des besoins flous ou une décision de conception que l'agent ne peut pas prendre le bloqueront ou, pire, l'enverront dans la mauvaise direction.
Avec un modèle hébergé performant, OpenHands gère bien les tâches multi-fichiers. Avec un petit modèle local, vous verrez des appels d'outils ratés et des réponses de type chatbot, et même avec une grande fenêtre de contexte, certains modèles locaux utilisent mal les outils.
Les boucles agent coûtent aussi plus cher que le chat. Chaque étape renvoie l'historique au modèle, et les longues tâches accumulent les étapes. La doc OpenHands prévient que l'agent envoie de nombreuses invites au LLM et recommande des plafonds de dépenses et un suivi d'usage. Le condenseur de contexte aide, mais il résume les étapes anciennes : des détails se perdent sur la durée.
L'accès aux outils ajoute un risque sécurité. Un agent avec un terminal et un réseau peut causer de vrais dégâts s'il suit de mauvaises instructions : d'où l'importance de la sandbox et de votre relecture.
Et chaque changement demande encore une approbation humaine. Gardez-le en tête.
OpenHands et l'avenir des agents de codage IA
Les outils de codage IA ont évolué de l'autocomplétion au chat, puis aux agents qui mènent une tâche entière. OpenHands fait partie des projets qui poussent cette étape.
La direction est claire dans l'industrie. Cursor décrit une ère émergente où des agents cloud autonomes prennent des tâches plus larges sur des durées plus longues. Copilot prend maintenant des issues depuis GitHub et Linear. Claude Code fonctionne dans le terminal, le navigateur et Slack.
Les plateformes open source ont un rôle spécifique dans ce mouvement. Avec OpenHands, vous pouvez inspecter le fonctionnement de l'agent, l'exécuter sur votre infrastructure et choisir le modèle. Pour des équipes aux règles de données strictes, c'est souvent la seule voie autorisée.
Les tâches longues amènent aussi de nouveaux défis. Un agent qui travaille une heure prend bien plus de décisions qu'en une minute, et chaque décision peut l'éloigner de l'objectif. De meilleurs modèles aident, tout comme les sandboxes, politiques d'approbation et relectures.
Conclusion
Ce qui distingue OpenHands de ses concurrents, c'est le contrôle. Vous pouvez lire le code source, l'héberger sur votre propre matériel et l'exécuter avec n'importe quel modèle, y compris local. Des outils commerciaux plus fermés comme Claude Code, Cursor et GitHub Copilot offrent une expérience plus polie, mais à leurs conditions.
Mais un agent avec accès à votre terminal et à vos dépôts a toujours besoin d'une relecture humaine. Pensez à lire le diff et à lancer les tests vous-même.
Pour apprendre à créer votre propre agent de A à Z, regardez notre webinaire Introduction to Creating AI Agents in Python.