Lu sur le blog
OpenComputer : L'IA qui code, mais chez toi

star

Illustration technique : An illustration in a tech blog style, depicting a developer's homelab setup with multiple screens, a keyboard, and a mouse. On one screen, there's a stylized representation of an AI agent, symbolized by a digital brain or a robot icon, interacting with a code editor. The overall atmosphere should be cozy but high-tech, with glowing interfaces and cables, suggesting self-hosting and control. No text.

Ces derniers mois, on ne parle que d'agents IA capables de coder, de refactorer, de débugger. Devin est sur toutes les lèvres, présenté comme le développeur autonome ultime. Franchement, l'idée est séduisante, mais confier mon précieux code, mes configurations, mes secrets de prod à une boîte tierce, ça me gratte un peu. Sans parler du coût. Du coup, ma veille m'a mené vers un projet qui coche toutes les cases : OpenComputer.

OpenComputer : Le développeur autonome, mais en open-source

Je suis tombé sur ce projet de DiggerHQ et j'ai tout de suite pigé le potentiel. OpenComputer, c'est un agent IA autonome, conçu pour opérer un ordinateur. Oui, tu as bien lu : il interagit avec un système d'exploitation via un client VNC. L'objectif est clair : offrir une alternative open-source et auto-hébergeable aux agents propriétaires. Imagine transformer n'importe quelle VM de ton homelab en un agent de codage multijoueur. C'est exactement ça.

Ce qui me plaît, c'est cette promesse de contrôle total. Plus besoin de prier pour la sécurité de tes données sur des serveurs inconnus. Tout est chez toi, sous ton pouce. Et pour un dev PHP comme moi, qui jongle avec des projets Symfony, des conteneurs Docker et des configs de serveurs, avoir un assistant qui peut manipuler un environnement Linux comme un humain, c'est une perspective dingue.

Installation dans ton homelab : Docker et Ollama à la rescousse

L'installation, tu t'en doutes, c'est du Docker. Simple, efficace, comme on aime. Le projet fournit un docker-compose.yml qui te permet de démarrer l'agent et, cerise sur le gâteau, d'intégrer Ollama pour utiliser des modèles de langage locaux. Adieu les API propriétaires, bonjour la confidentialité !

Voici la base de ce que tu peux balancer dans ton docker-compose.yml. J'ai adapté l'exemple pour qu'il soit parlant avec Ollama, parce que si on self-hoste, autant aller jusqu'au bout, non ?

services:
  opencomputer:
    image: diggerhq/opencomputer
    container_name: opencomputer
    ports:
      - "8000:8000"
    environment:
# Clé API OpenAI (si tu veux utiliser leurs modèles, sinon supprime)
# OPENAI_API_KEY: 'sk-...'
# Modèle par défaut, tu peux mettre un modèle Ollama ici
      OPENCOMPUTER_MODEL: 'ollama/llama3'
      OPENCOMPUTER_VNC_PASSWORD: 'ton_mot_de_passe_vnc_securise'
      OPENCOMPUTER_WORKSPACE_PATH: '/app/workspace'
    volumes:
      - './workspace:/app/workspace'
      - '/var/run/docker.sock:/var/run/docker.sock'
# Pour interagir avec Docker sur l'hôte
    depends_on:
      - ollama

  ollama:
    image: ollama/ollama
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - './ollama_models:/root/.ollama'
    command: serve

Quelques notes sur cette config :

  • J'ai mis OPENCOMPUTER_MODEL: 'ollama/llama3' pour forcer l'usage d'un modèle Ollama. Pense à le télécharger via docker exec ollama ollama pull llama3 une fois le service Ollama démarré.
  • Le volume ./workspace:/app/workspace est crucial : c'est là que l'agent va lire et écrire tes fichiers.
  • Le /var/run/docker.sock est un petit hack pour que l'agent puisse lancer des commandes Docker sur ton hôte. Attention, c'est puissant, à n'utiliser que si tu sais ce que tu fais et dans un environnement sécurisé !
  • N'oublie pas de changer 'ton_mot_de_passe_vnc_securise'. C'est le mot de passe pour accéder à l'interface VNC de l'agent.

Une fois ton docker-compose.yml prêt, un simple docker compose up -d et le tour est joué. Tu peux ensuite te connecter à l'interface web d'OpenComputer (généralement sur localhost:8000) et commencer à lui donner des tâches.

Comment ça marche, ce truc ?

L'architecture est assez brillante dans sa simplicité. OpenComputer ne fait pas de magie noire. Il utilise un LLM pour raisonner et générer des actions. Ces actions, il les exécute sur un environnement virtualisé (via VNC). En gros, l'IA voit l'écran de la VM, peut taper au clavier, bouger la souris, ouvrir des terminaux, lancer des commandes. C'est comme si un humain était devant la machine, mais en version automatisée.

Pour nous, développeurs PHP, ça signifie qu'il peut cloner un dépôt Git, lancer un composer install, modifier un fichier Symfony, exécuter des tests unitaires, etc. Le LLM lui donne la capacité de comprendre ta demande, de la décomposer en étapes et d'interagir avec l'environnement pour les réaliser. C'est une boucle de perception-action-réflexion. Il agit, observe le résultat, et adapte sa prochaine action.

Cas d'usage concrets pour un dev PHP

Bon, c'est bien beau la théorie, mais dans la vraie vie, ça donne quoi ?

  1. Refactoring de code Symfony : Tu peux lui demander de refactorer un contrôleur un peu trop gros, ou de transformer des services couplés en services plus granulaires. L'agent va ouvrir les fichiers, proposer des modifications, et même lancer les tests pour vérifier que rien n'est cassé.
  2. Ajout de petites fonctionnalités : Besoin d'ajouter un champ à une entité Doctrine, générer la migration, mettre à jour le formulaire associé et ajouter un test fonctionnel ? Tu peux lui donner la tâche. Il va interagir avec bin/console make:entity, modifier ton code, et potentiellement même générer le fichier de test.
  3. Débuggage d'erreurs courantes : Une erreur 500 mystérieuse en prod ? Tu peux lui donner l'accès aux logs, et lui demander d'analyser le problème. Il pourra même tenter des corrections et te proposer un patch.
  4. Mise à jour de dépendances : Lancer un composer update, analyser les changements, vérifier les tests, c'est une tâche répétitive qu'un agent pourrait gérer.

Attention, on parle d'un agent généraliste, pas d'un assistant PHP spécialisé. Il ne remplacera pas un outil comme PHPStan pour l'analyse statique, mais il peut *utiliser* PHPStan dans le terminal pour toi. C'est la différence : il opère l'ordinateur.

Avantages du self-hosting : Contrôle, confidentialité et personnalisation

Pour moi, c'est LA raison d'être d'OpenComputer. Le self-hosting, c'est la liberté et la sécurité :

  • Confidentialité des données : Ton code, tes secrets, tes configurations restent chez toi. Pas de fuite possible vers des serveurs tiers. C'est inestimable, surtout pour des projets sensibles.
  • Contrôle total : Tu maîtrises l'environnement. Tu choisis tes LLM (locaux avec Ollama, ou des API si tu as confiance), tu gères les ressources allouées à l'agent, tu peux inspecter son comportement.
  • Personnalisation : Tu peux adapter l'environnement de la VM à tes besoins spécifiques. Installer tes outils préférés, tes plugins VSCode, tes alias bash. L'agent apprendra à travailler dans TON environnement.
  • Coût maîtrisé : Pas d'abonnement mensuel qui gonfle avec l'usage. Juste l'électricité de ton homelab et la puissance de ton GPU si tu utilises des LLM locaux gourmands.

C'est un peu le même esprit que de self-hoster son Gitlab ou son Gitea plutôt que d'être dépendant de GitHub. Pour les agents IA, c'est encore plus critique vu la nature des tâches qu'on leur confie.

Limitations actuelles et feuille de route

Soyons clairs : OpenComputer est un projet jeune, en développement actif. Ce n'est pas encore le développeur senior qui va te sortir une feature complexe de A à Z sans supervision. Il y a des limites :

  • Fiabilité : Comme tout agent IA autonome, il peut parfois « halluciner » ou se perdre dans ses raisonnements. Il faut le superviser, surtout au début.
  • Complexité des tâches : Les tâches très ouvertes ou qui demandent une compréhension contextuelle profonde d'un projet entier peuvent être difficiles pour lui. Mieux vaut commencer par des tâches bien définies.
  • Performance des LLM locaux : Si tu utilises Ollama avec un modèle léger, les capacités de raisonnement seront moindres qu'avec un GPT-4o. C'est un compromis à faire entre confidentialité et intelligence brute.

La feuille de route est ambitieuse, et le projet est très actif sur GitHub. Je pense que dans les mois à venir, on verra des améliorations significatives en termes de robustesse et de capacité à gérer des workflows plus complexes. C'est un projet à suivre de très près pour quiconque s'intéresse aux agents autonomes et au self-hosting.

Verdict : Un compagnon prometteur pour ton homelab

OpenComputer, c'est clairement le genre de projet qui m'excite. C'est la promesse d'une IA au service du développeur, mais une IA sous notre contrôle, respectueuse de notre vie privée et de nos données. Pour l'instant, c'est plus un outil pour les bidouilleurs et les explorateurs, mais le potentiel est énorme.

Si tu as un homelab qui tourne et l'envie de mettre les mains dans le cambouis pour expérimenter avec les agents IA, fonce. C'est une excellente base pour comprendre comment ces systèmes fonctionnent et pour préparer l'avenir du développement assisté par IA, mais à tes propres conditions. Je suis convaincu que ce genre d'approche va devenir incontournable pour les développeurs soucieux de leur autonomie. À tester absolument ce week-end !

Publié le 22 novembre 2026 Partager X LinkedIn

← Précédent Raea : ton agent écrit du React, ton GPU rend la vidéo