Il y a une petite différence entre demander quelque chose à une IA et donner quelque chose à faire à une IA. C’est une nuance qui peut sembler anodine, mais qui change complètement la façon dont on utilise ces outils.
Avec un chatbot classique, je peux lui demander :
« Comment vérifier mes conteneurs Docker ? »
Il va gentiment me répondre avec une commande du genre docker ps. Très bien. Mais ensuite… c’est moi qui ouvre le terminal, tape la commande, regarde le résultat, lui copie-colle les logs, attends son analyse, puis retourne dans le terminal pour appliquer la correction. L’IA réfléchit, Moi, je fais le boulot.
Avec un agent comme Pi, la philosophie est différente.
Je peux lui demander :
« Regarde mes conteneurs Docker et trouve pourquoi celui-ci ne démarre pas. »
Et là, l’IA peut réellement agir dans son environnement : consulter des fichiers, exécuter des commandes, analyser les résultats, modifier du code ou des fichiers et poursuivre son travail en fonction de ce qu’elle découvre. Et c’est précisément là que Pi devient intéressant.
Pi n’est pas une IA
Premier point important : Pi n’est pas un modèle d’intelligence artificielle. Pi n’est pas « un nouveau ChatGPT ». Il faut plutôt voir Pi comme une sorte d’environnement de travail pour un modèle d’IA. Le modèle constitue le cerveau. Pi lui fournit les outils et l’environnement qui lui permettent d’agir.
On peut donc schématiser les choses très simplement :
LE CERVEAU
Claude / GPT / Gemini
ou autre
│
▼
┌──────────────┐
│ PI AGENT │
└──────┬───────┘
│
┌────────┼────────┐
▼ ▼ ▼
Fichiers Shell Outils
│ │ │
└────────┼────────┘
▼
Mon système
Pi fait donc le lien entre le modèle et le monde réel. Enfin… le monde réel de mon ordinateur. Et c’est là que ça commence à devenir amusant.
Du chatbot à l’agent
Pendant longtemps, notre relation avec les IA ressemblait finalement beaucoup à une conversation avec un expert. On pose une question. L’IA répond. On pose une autre question. Elle répond encore. Mais elle reste essentiellement spectatrice de ce qui se passe sur notre machine. Un agent change cette relation.
On ne lui demande plus uniquement :
« Comment faire ? »
On peut lui demander :
« Fais-le. »
Évidemment, cette phrase mérite quelques précautions. Un agent ne devient pas soudainement omnipotent. Il possède uniquement les capacités et les outils qu’on lui donne, et il reste fortement dépendant du modèle utilisé.
Mais lorsqu’on lui donne accès au terminal, aux fichiers ou à certains outils, il peut commencer à enchaîner des actions de manière autonome. C’est cette capacité d’action qui constitue, à mes yeux, la vraie différence.
Pi, c’est donc quoi ?
Pi est un agent IA orienté terminal, conçu pour travailler directement dans un environnement de développement ou d’administration. Il peut notamment lire et modifier des fichiers, exécuter des commandes et utiliser différents outils pour accomplir une tâche. Et surtout, Pi a été pensé pour être extensible.
Plutôt que de construire une énorme interface remplie de boutons censés prévoir tous les usages possibles, le projet adopte une philosophie beaucoup plus modulaire. On peut l’étendre avec des extensions, des skills, des templates et différents outils.
Autrement dit :
Pi fournit les fondations.
Ensuite, c’est à nous de décider jusqu’où on veut pousser la machine.
Pourquoi cela m’intéresse particulièrement dans un HomeLab ?
C’est là que Pi commence réellement à avoir du sens dans mon cas. Dans mon projet Amaterasu, je ne cherche pas simplement à avoir une IA capable de discuter avec moi. J’expérimente avec un environnement où l’IA peut progressivement avoir accès à différents services :
- Docker
- fichiers
- scripts
- recherches web
- mémoire
- différents modèles d’IA
- automatisations
- et, à terme, différents outils capables d’interagir avec mon infrastructure.
Jusqu’ici, j’ai surtout travaillé sur le cerveau de mon installation. Pi m’intéresse parce qu’il apporte quelque chose de différent : la capacité d’agir.
Et forcément, ça soulève immédiatement une question assez importante :
Que se passe-t-il lorsqu’on donne réellement les clés du terminal à une IA ?
C’est précisément ce que je suis en train de tester. Et, accessoirement, c’est probablement une très mauvaise idée de me laisser jouer avec ça un vendredi soir. Mais c’est justement ce qui rend l’expérience intéressante.
À quoi sert Pi Agent concrètement ?
Maintenant qu’on a compris ce qu’est Pi, une question assez légitime se pose : Mais concrètement, je peux en faire quoi ?
Et c’est probablement là que Pi devient vraiment intéressant. Parce qu’un agent qui se contente de discuter avec moi n’est finalement pas très différent d’un chatbot classique. L’intérêt commence lorsqu’il peut observer, réfléchir et agir.
Un assistant qui peut réellement travailler
Imaginons que je travaille sur un petit projet Python.
Avec un chatbot classique, je peux lui demander :
« J’ai cette erreur dans mon programme, tu sais d’où ça vient ? »
Je lui colle mon code. Il analyse. Il me répond. Puis je retourne dans mon éditeur pour modifier le fichier.
Avec Pi, je peux simplement lui dire :
« Regarde mon projet et trouve pourquoi ça plante. »
Pi peut alors parcourir les fichiers concernés, analyser le code, exécuter certaines commandes, constater le résultat et proposer une correction. Et dans certains cas, il peut même effectuer lui-même la modification. La différence paraît petite. En réalité, elle est énorme. Je ne suis plus simplement en train de demander conseil à une IA. Je lui demande de travailler avec moi sur mon environnement.
Et ça ne concerne pas uniquement le développement
C’est probablement une des choses que j’ai trouvées les plus intéressantes dans le concept. Pi n’est pas uniquement destiné à écrire du code. Puisqu’il peut interagir avec un environnement via ses outils, les possibilités deviennent beaucoup plus larges.
Par exemple :
🐳 Docker
« Vérifie pourquoi mon conteneur ne démarre pas. »
Pi peut inspecter les conteneurs, consulter les logs et chercher ce qui bloque.
📁 Fichiers
« Cherche dans ce projet tous les fichiers qui utilisent cette ancienne configuration. »
Il peut parcourir l’arborescence et rechercher les occurrences.
🖥️ Administration système
« Vérifie l’espace disque et dis-moi ce qui prend le plus de place. »
Il peut utiliser les commandes système nécessaires et analyser leur résultat.
💻 Développement
« Ajoute cette fonction à mon script et vérifie qu’elle fonctionne. »
Il peut explorer le projet, modifier les fichiers concernés et effectuer des tests.
🔄 Automatisation
Et c’est probablement ici que les choses deviennent particulièrement intéressantes pour un HomeLab. Un agent peut devenir une sorte d’interface naturelle entre l’utilisateur et toute une infrastructure. Au lieu de devoir connaître la commande exacte pour chaque opération, je peux progressivement passer par une demande en langage naturel. L’IA devient alors une sorte de couche d’abstraction entre moi et ma machine.
Comment installe-t-on Pi ?
Et bonne nouvelle : malgré tout ce qu’on vient de raconter, l’installation n’a rien d’une opération chirurgicale. Pi peut être installé via npm, le gestionnaire de paquets de Node.js. Une fois Node.js disponible sur la machine, l’installation peut se faire avec :
npm install -g @mariozechner/pi-coding-agentPuis il suffit de lancer :
piEt nous voilà dans le monde merveilleux du terminal. Pas de grosse interface graphique. Pas de tableau de bord futuriste. Pas de petit avatar qui vous regarde avec des yeux brillants. C’est dommage, mais au final … on veut quelque chose de puissant, pas d’une truc flashy.
Juste :
$ piEt une IA qui attend qu’on lui parle. Personnellement, je trouve que cette approche a quelque chose d’assez amusant. On a passé des années à essayer de rendre les interfaces informatiques toujours plus jolies… Et nous voilà en 2026 à donner des ordres
Qui est derrière Pi Agent ?
Maintenant que l’on sait ce que Pi peut faire, une autre question mérite d’être posée : Mais qui a décidé qu’une IA devait avoir accès à mon terminal ?
Derrière Pi, on retrouve Mario Zechner, plus connu dans le monde du développement sous le pseudo badlogic. Si ce nom ne vous dit rien, il n’est pourtant pas nouveau dans l’univers du développement open source. Mario Zechner est notamment connu pour avoir créé libGDX, un framework Java open source permettant de développer des jeux sur plusieurs plateformes. Autrement dit, le bonhomme n’arrive pas exactement de nulle part avec un prompt ChatGPT et trois lignes de JavaScript.
Pi n’est pas qu’un programme
Le projet que l’on appelle généralement « Pi » repose en réalité sur un ensemble de briques regroupées dans un monorepo appelé pi-mono. Et c’est probablement une des premières choses qui m’a intéressé en regardant un peu plus profondément le projet.
On y retrouve notamment plusieurs composants :
pi-aipour l’accès aux différents fournisseurs de modèlespi-agent-corepour le moteur de l’agentpi-coding-agentpour l’agent utilisable depuis le terminalpi-tuipour l’interface terminalpi-web-uipour les interfaces web- ainsi que d’autres briques destinées à des usages comme Slack ou les déploiements de modèles.
En clair, Pi n’est donc pas simplement :
« une interface permettant de discuter avec une IA ».
C’est plutôt une boîte à outils permettant de construire et d’utiliser des agents IA. Et cette distinction devient importante lorsqu’on commence à regarder comment le projet a été pensé.
Une philosophie assez différente
Ce qui m’intéresse particulièrement dans Pi, ce n’est pas seulement ce qu’il sait faire aujourd’hui. C’est surtout la manière dont il a été conçu. Beaucoup d’outils IA essaient de cacher toute la complexité derrière une interface graphique. On clique, on sélectionne, on configure, on lance. Pi prend une direction presque opposée. Il assume complètement son côté terminal. Et surtout, il laisse énormément de place à la personnalisation et à l’extension.
Le projet fournit les fondations, puis permet d’ajouter des fonctionnalités supplémentaires sous forme d’extensions, de skills, de templates ou de packages. C’est une philosophie qui parle forcément assez bien à quelqu’un qui construit un HomeLab.
Parce qu’en HomeLab, on a rarement envie qu’un outil nous dise :
« Voilà comment tu dois utiliser mon logiciel. »
On préfère généralement :
« Donne-moi les briques et laisse-moi bricoler. »
Et Pi semble clairement s’inscrire dans cette logique.
Un projet open source
Autre élément important : Pi est un projet open source, distribué sous licence MIT. Et cela change beaucoup de choses. On peut évidemment simplement installer Pi et l’utiliser comme n’importe quel autre logiciel. Mais on peut aussi aller regarder comment tout cela fonctionne, modifier, etendre et créer ses propres outils. Construire ses propres workflows. Et surtout, comprendre ce qui se passe derrière l’interface. C’est finalement assez cohérent avec l’esprit du projet. Pi n’essaie pas forcément de faire disparaître la mécanique. Il nous la montre.
Le modèle n’est pas enfermé dans Pi
Il y a également un choix architectural particulièrement intéressant. Pi n’est pas marié à un seul fournisseur d’IA. La brique pi-ai fournit une API permettant de travailler avec plusieurs fournisseurs et modèles, notamment OpenAI, Anthropic et Google.
C’est important parce que cela sépare deux choses : le cerveau et l’agent.
Le modèle peut changer mais l’agent reste.
Et cela permet d’imaginer différents scénarios :
PI AGENT
│
┌───────────┼───────────┐
│ │ │
GPT Claude Gemini
│ │ │
└───────────┼───────────┘
│
▼
Même environnement
│
┌─────────┼─────────┐
▼ ▼ ▼
Fichiers Shell Outils
Pour mon projet Athena, cette séparation est particulièrement intéressante. Je peux expérimenter avec différents modèles sans devoir reconstruire toute mon architecture autour d’un fournisseur unique. Et dans un projet HomeLab où l’objectif est justement de tester, comparer et bricoler différentes technologies IA, cette liberté a beaucoup de sens.
Une philosophie qui colle plutôt bien au HomeLab
Finalement, je pense que c’est probablement la raison pour laquelle Pi m’a intrigué. Ce n’est pas forcément l’outil le plus spectaculaire à regarder. Il n’a pas besoin d’une interface futuriste pour impressionner.
Il part d’une idée assez simple :
Voici un agent. Voici ses outils. Maintenant, voyons ce que vous voulez construire avec.
Et c’est exactement le genre de philosophie qui me plaît dans un HomeLab. Parce qu’une fois qu’on commence à bricoler, une question revient toujours :
« Et si je faisais ça ? »
Puis :
« Et si je lui donnais accès à ça aussi ? »
Et généralement, c’est précisément à ce moment-là que les choses commencent à partir légèrement en vrille.
Dans mon cas, c’est également à ce moment que Pi est passé du statut de « outil intéressant à tester » à « nouvelle pièce potentielle d’Amaterasu ». Et à partir de là, il fallait évidemment que je teste une chose essentielle : qu’est-ce que ça donne vraiment quand on l’utilise au quotidien ?
Quand l’IA commence à travailler toute seule
Bon.
Maintenant que nous avons fait le tour de la théorie, parlons de ce qui m’intéresse vraiment : qu’est-ce que ça donne quand on laisse réellement Pi Agent travailler dans un HomeLab ?
Parce que c’est bien joli de vous expliquer qu’un agent peut lire des fichiers, exécuter des commandes et modifier une configuration.
Mais entre :
« Oui, techniquement, il peut le faire. »
et :
« Attends… il vient vraiment de faire ça tout seul ? »
… il y a un monde. Et c’est précisément ce que j’ai commencé à découvrir avec Amaterasu.
Première expérience : je demande à mon IA d’installer Pi
La première expérience est assez amusante. Je possède déjà une IA que j’ai montée directement dans mon HomeLab. Plutôt que de me connecter à la VM et de faire moi-même l’installation de Pi Agent, j’ai donc décidé de demander à mon propre agent IA de le faire pour moi.
La demande était finalement assez simple :
« Installe Pi Agent sur cette VM. »
Et là… Ça fonctionne. Du premier coup. Je m’attendais presque à devoir intervenir à un moment donné. Une dépendance manquante. Une permission. Une version de Node.js incompatible. Un truc quelconque qui allait forcément décider de me rappeler que l’informatique est une science exacte pratiquée par des gens qui ne le sont pas. Mais non. Pi est installé et il fonctionne.
Et puisqu’on était lancés…
Je me suis dit :
« Maintenant, demande-lui de te faire une interface Web. »
L’idée était simple : je voulais pouvoir discuter avec Pi directement depuis une interface Web plutôt que de passer systématiquement par la ligne de commande. Sauf que mon IA est locale. Et elle n’est pas exactement montée sur une fusée. Donc…
1 heure. Oui.Une bonne heure à regarder mon LLM local travailler, et puis finalement : pouf. Une interface Web apparaît. Une vraie.
Je peux maintenant ouvrir mon navigateur et discuter avec Pi sans avoir à passer par le terminal. À ce moment-là, j’ai commencé à comprendre quelque chose. Je n’étais plus simplement en train de tester Pi. J’étais en train de lui demander de construire l’environnement dans lequel j’allais l’utiliser. Et ça, c’est plutôt amusant.
« Fais-moi un audit de sécurité »
Une fois Pi installé, forcément, il fallait tester quelque chose d’un peu plus sérieux. Je lui ai demandé de réaliser un audit de sécurité de mon environnement, et là, j’avoue avoir été assez agréablement surpris. Pi a commencé à explorer le réseau. Il a cherché, analysé, il a remonté les différents éléments qu’il trouvait. Et surtout… il a trouvé des choses. Pas de grosse catastrophe.
Pas de :
« Félicitations, votre HomeLab est actuellement utilisé par un gang de cybercriminels roumains. »
Et ça, c’est déjà plutôt rassurant. La majorité des éléments remontés comme potentiellement problématiques étaient en réalité connus et assumés. Certaines configurations sont volontairement ouvertes parce que Pi évolue dans un environnement très particulier : un réseau LAN fermé, derrière mon environnement Proxmox.
Ce qui serait une mauvaise pratique dans un serveur exposé sur Internet peut donc avoir un niveau de risque complètement différent dans mon environnement.
Cela ne signifie évidemment pas :
« LAN = sécurité absolue. »
Mais plutôt :
le niveau de sécurité nécessaire dépend aussi du contexte dans lequel le système évolue.
Et l’intérêt de l’audit était justement de mettre ces choix face à un regard extérieur. Pi m’a donc permis de vérifier quelque chose que je pensais déjà savoir : je connaissais mes compromis. Mais surtout, je pouvais désormais les faire vérifier automatiquement.
« Ton contexte est trop petit »
C’est probablement l’expérience qui m’a le plus impressionné. À un moment donné, j’ai commencé à rencontrer une limitation assez classique avec les agents IA :
« Ton contexte est trop petit. »
Plus je lui demandais de travailler sur Amaterasu, plus je sentais que la quantité d’informations qu’il devait conserver devenait importante. Configuration, Historique, Architecture, Fichiers, Décisions précédentes, Résultats de tests, Erreurs et Documentation. Bref… un joyeux bordel de HomeLab.
Je lui ai donc posé une question assez directe :
« Comment peut-on faire pour que tu sois plus performant et plus précis ? »
Et là, plutôt que de me répondre avec trois conseils génériques sur le prompt engineering… je l’ai laissé travailler.
Le week-end le plus calme de ma vie
Pendant le week-end, Pi a donc travaillé sur son propre environnement. Et après un bon moment à gratter, tester, modifier, vérifier… Il revient vers moi avec quelque chose du genre :
« C’est bon. J’ai tout fait. J’ai testé. »
Bon. D’accord. Mais le plus intéressant n’était pas vraiment le résultat final. C’était la manière dont il y était arrivé. Pendant que je l’observais travailler, j’ai découvert quelque chose d’assez surprenant. Pi avait créé… une autre instance de Pi Agent. Oui. Vous avez bien lu. Pi avait installé une instance de Pi pour pouvoir tester Pi.
Il a utilisé cette instance comme environnement de test, effectué différentes expérimentations dessus, vérifié les résultats, puis est revenu vers mon instance principale avec une configuration qu’il considérait comme suffisamment fiable pour être appliquée. Et seulement après validation, cette configuration a été appliquée à l’instance principale.
À ce moment-là, j’ai eu ce petit moment de silence devant l’écran. Parce que techniquement, ce n’était pas particulièrement spectaculaire. Mais conceptuellement… c’était sacrément intéressant. L’agent avait créé son propre environnement de test pour modifier son environnement principal.
Autrement dit :
« Je vais éviter de casser la production en allant d’abord casser mon environnement de test. »
C’est probablement une des premières fois où j’ai réellement commencé à considérer Pi comme autre chose qu’un simple outil.
finalement, je ne fais plus grand-chose
Il y a une autre chose que j’ai rapidement mise en place. J’aime bien les comptes rendus. J’aime savoir ce qui a été fait. J’aime comprendre pourquoi quelque chose a été modifié. Et surtout, j’aime pouvoir revenir en arrière dans l’histoire d’une modification. J’ai donc demandé à Pi de me faire systématiquement un compte rendu après chaque intervention.
Depuis…
Je ne sais pas si je peux vraiment dire que je suis devenu productif. Mais je suis devenu très bien informé. Le matin, je bois mon café. J’ouvre mes comptes rendus.
Et je découvre ce que Pi a fait pendant la nuit.
« Cette nuit, j’ai modifié ceci. »
« J’ai rencontré cette erreur. »
« J’ai effectué ce test. »
« J’ai identifié ce problème. »
« J’ai appliqué cette correction. »
Et moi, pendant ce temps : café, Lecture, Analyse, Validation. Parfois une petite correction.
Et surtout :
« Mais attends… pourquoi tu as fait ça ? »
C’est probablement l’un des effets secondaires les plus amusants de l’utilisation d’un agent. Au lieu de passer mon temps à exécuter des commandes, je passe davantage de temps à superviser ce qu’il fait. Et ça change complètement la relation avec la machine.
STRATA, ou comment donner une Ferrari à quelqu’un qui apprend encore à conduire
Et puis j’ai voulu aller un peu plus loin. J’ai commencé à expérimenter avec STRATA.
Et là…
C’est devenu beaucoup moins simple. Le problème n’est pas vraiment l’installation de STRATA. Le problème, c’est ce qui se passe ensuite. Avec Qwen Flash Next, les capacités sont nettement supérieures à ce que j’avais l’habitude d’utiliser avec mon environnement local.
Et surtout… ça va très vite. Vraiment très vite. Le modèle envoie énormément d’informations et peut enchaîner les opérations à une vitesse qui devient presque trop importante pour Pi dans ma configuration actuelle.
Résultat ? Le contexte se remplit. Très vite. Trop vite.
Et Pi commence à s’étouffer. Puis arrivent les erreurs. Puis les boucles. Puis les erreurs dans les erreurs. Puis… Pi repart.
Quelques minutes plus tard :
« Bonjour, que puis-je faire pour vous ? »
Et moi :
« On avait déjà eu cette conversation… »
J’ai même observé des situations où il repartait dans une sorte de boucle au bout de quelques minutes. Bref. On était loin du système prêt pour la production.
Le problème n’est donc pas forcément la puissance
Et c’est probablement l’un des enseignements les plus intéressants de cette expérimentation.
On pourrait penser :
Plus le modèle est puissant, mieux c’est.
En réalité, ce n’est pas aussi simple. Dans mon cas, le passage vers un modèle beaucoup plus puissant a aussi mis en évidence certaines limites de l’environnement autour de Pi. Le modèle peut aller plus vite. Réfléchir davantage. Produire davantage. Enchaîner davantage d’actions. Mais si le reste de la chaîne ne suit pas… ça casse.
Et c’est là que j’ai compris qu’un agent IA n’était pas simplement :
modèle + terminal = magie.
Il y a toute une chaîne technique derrière.
Ollama contre STRATA
Autre expérience intéressante : essayer de faire fonctionner Pi avec différents gestionnaires d’inférence. Dans mon environnement, j’utilise notamment Ollama avec un modèle local de type Qwen 3.8 27B.
Ça fonctionne. Ce n’est pas forcément spectaculaire. Mais c’est relativement simple, prévisible et suffisamment stable pour mes besoins.
STRATA, de son côté, me permet d’exploiter un modèle beaucoup plus gros et beaucoup plus puissant, notamment Qwen Flash Next 115B dans mes expérimentations.
Et là…
C’est un peu comme passer d’une voiture sympa à une GTI 16S.
« Wouhaaaaaa ! »
Ça pousse. Ça accélère. Ça envoie.
Mais… il faut aussi savoir la conduire. Et surtout, il faut que les pneus, les freins et le châssis suivent. C’est exactement le problème que je rencontre actuellement. STRATA apporte énormément de puissance. Mais cette puissance fragilise aussi mon environnement Pi lorsque tout n’est pas correctement configuré.
Et pourtant… Pi continue d’essayer
C’est probablement ce qui me plaît le plus dans toute cette histoire. Même lorsque je lui donne un environnement compliqué, que je lui colle un modèle beaucoup plus puissant et que tout commence à partir en vrille…
Pi ne me répond pas simplement :
« Désolé, ça ne marche pas. »
Il essaie. Il analyse. Il teste. Il recommence. Il cherche une autre configuration. Il expérimente. Et parfois… (souvent), Il se plante. Mais il essaie encore. C’est une différence fondamentale avec un simple chatbot. Un chatbot peut m’expliquer pendant vingt minutes pourquoi quelque chose ne fonctionne pas.
Un agent peut me dire :
« Attends. Je vais essayer quelque chose. »
Et partir travailler. C’est exactement ce comportement qui me plaît avec Pi.
Alors oui… je joue encore avec
À ce stade de mes expérimentations, je suis encore loin d’avoir un Pi Agent parfaitement configuré et prêt à être lâché sans surveillance sur toute mon infrastructure. Et c’est très bien comme ça.
Parce que ce que je voulais au départ était simplement :
tester Pi.
Je me retrouve maintenant avec un agent qui peut installer des logiciels, modifier sa configuration, tester des environnements, auditer mon réseau, produire des comptes rendus et travailler pendant que je bois mon café.
Et accessoirement…
il m’a déjà montré qu’un agent IA suffisamment autonome peut devenir beaucoup plus intéressant lorsqu’on arrête de lui demander uniquement des réponses et qu’on commence à lui demander de travailler.
La prochaine étape sera donc de comprendre ce que tout cela vaut réellement sur le plan technique.
Parce qu’entre : « Ça fonctionne chez moi » et « Je peux mettre ça en production sans avoir peur de me réveiller avec un HomeLab en feu » …
il y a encore du chemin a faire, Et justement, c’est probablement là que mon expérimentation avec Pi devient vraiment intéressante.
Alors, on en pense quoi ?
Après plusieurs jours à laisser Pi Agent mettre les mains dans mon HomeLab, il est temps de répondre à la question la plus importante : Est-ce que Pi est vraiment intéressant ?
La réponse courte est : Oui.
Mais pas forcément pour les raisons auxquelles on pourrait penser. Pi n’est pas simplement un autre chatbot. Ce n’est pas non plus une solution magique qui va administrer votre infrastructure pendant que vous partez en vacances. C’est un agent. Et cette différence change énormément de choses.
Pi n’est pas magique
La première chose que j’ai apprise avec Pi, c’est qu’un agent aussi bon soit-il reste dépendant de son environnement. Le modèle utilisé compte énormément. La taille du contexte compte. Les outils disponibles comptent. La configuration compte. Les permissions comptent. Et surtout… la manière dont on lui donne accès à notre infrastructure compte énormément.
Donner un terminal à une IA, ce n’est pas exactement la même chose que lui demander de rédiger un mail. Une mauvaise réponse dans ChatGPT peut être agaçante. Une mauvaise commande exécutée sur un serveur peut être beaucoup plus amusante. Enfin… pas pour le serveur.
Mais quand ça fonctionne…
Quand tout est correctement configuré, Pi devient particulièrement intéressant. Il peut passer d’un outil qui répond à mes questions à un véritable assistant technique capable d’agir. Il peut analyser, chercher, tester, modifier, vérifier, recommencer et surtout, il peut enchaîner plusieurs opérations sans que je sois obligé de lui tenir la main à chaque étape. C’est probablement cette autonomie qui m’a le plus marqué pendant mes expérimentations. Le meilleur exemple reste finalement cette fameuse instance de test.
Je lui demande d’améliorer son environnement. Il analyse et il construit une instance de test. Il expérimente dessus, il vérifie ses modifications et il revient avec une configuration qu’il applique à l’instance principale.
À ce moment-là, on n’est plus vraiment dans :
« L’IA m’explique comment faire. »
On commence à être dans :
« L’IA travaille sur le problème et me présente le résultat. »
Et pour moi, c’est précisément là que les agents deviennent réellement intéressants.
Le plus gros changement : mon rôle
Finalement, Pi a également changé ma manière d’utiliser mon HomeLab. Avant, j’étais principalement celui qui faisait. Je lançais les commandes. Je regardais les logs. Je modifiais les fichiers. Je testais, corrigeais, mais aujourd’hui, avec Pi, je passe davantage de temps à superviser.
Je donne une direction. Je regarde ce qu’il fait. Je lis ses comptes rendus, je valide, je corrige lorsqu’il part dans la mauvaise direction. Et parfois… je lui demande pourquoi il vient de faire ce qu’il vient de faire. Ce dernier point est important. Parce que je ne pense pas que l’objectif soit de construire une IA à laquelle on abandonne complètement les commandes de notre infrastructure.
L’objectif est plutôt de construire un collaborateur technique. Un collaborateur extrêmement rapide. Extrêmement motivé. Qui ne dort jamais. Qui peut travailler toute la nuit. Et qui a parfois des idées légèrement inquiétantes.
Et STRATA dans tout ça ?
Mon expérience avec STRATA m’a également appris quelque chose d’important. Plus puissant ne veut pas forcément dire plus stable. Un modèle plus performant peut faire beaucoup plus de choses.
Mais il peut également produire énormément plus d’informations, aller beaucoup plus vite et mettre davantage de pression sur toute la chaîne technique autour de lui.
Avec Ollama et un modèle local plus raisonnable, mon environnement est relativement prévisible.
Avec STRATA et un modèle beaucoup plus puissant, les possibilités explosent… Mais la configuration devient beaucoup plus délicate.
Et c’est précisément le genre de problème que je trouve intéressant dans un HomeLab.
Parce que finalement, ce n’est pas :
« J’ai installé Pi, ça fonctionne, fin de l’histoire. »
C’est :
« J’ai installé Pi. Maintenant, jusqu’où puis-je aller ? »
Et évidemment… c’est généralement à partir de cette phrase que les problèmes commencent.
Mon verdict
Si je devais résumer Pi en quelques mots :
🧠 Un cerveau
Pi peut utiliser différents modèles et profiter de leurs capacités.
🛠️ Des mains
Il peut accéder à des outils, au terminal, aux fichiers et à différents environnements.
🔌 Une architecture extensible
On peut l’adapter à ses propres besoins plutôt que de rester enfermé dans un workflow prédéfini.
⚠️ Et des responsabilités
Parce qu’une IA capable d’agir doit être traitée avec beaucoup plus de précautions qu’une IA qui se contente de discuter.
Est-ce que je vais continuer à utiliser Pi ?
Oui. Très clairement. Je suis même loin d’avoir terminé mes expérimentations. Pi est désormais devenu une nouvelle pièce de mon environnement Amaterasu et je commence seulement à voir ce qu’il est possible d’en faire.
Parce que finalement, c’est probablement ça que j’aime le plus dans ce genre de projet. Je ne sais pas encore exactement où ça va m’emmener. Et c’est justement pour ça que je continue.
Et maintenant ?
Au départ, je voulais simplement installer un agent IA. Aujourd’hui, j’ai une IA qui peut travailler sur mon infrastructure pendant que je bois mon café le matin et que je lis tranquillement son compte rendu.
Je pense que c’est probablement le meilleur résumé de mon expérience avec Pi. Je ne lui demande plus uniquement des réponses. Je lui donne des problèmes. Et pendant que je regarde ce qu’il fait…
☕ je bois mon café. Bienvenue dans le HomeLab IA.