Annuler pour l'IA : Pourquoi nous avons créé la gestion des versions de fichiers

Le problème de donner un stylo à l’IA

Voici quelque chose que personne ne vous dit sur les agents IA autonomes : ce sont des écrivains prolifiques sans concept de “êtes-vous sûr ?”

Un agent IA demandé de “modifier ce document” réécrira l’intégralité. Un agent demandé de “nettoyer ce code” restructurera chaque fichier qu’il touche. Un agent exécutant une tâche en arrière-plan créera, modifiera et supprimera des fichiers sans demander de permission — parce que vous lui avez dit de fonctionner de manière autonome.

La plupart du temps, les résultats sont bons. Mais “la plupart du temps” n’est pas suffisant quand l’alternative est de perdre un travail que vous ne pouvez pas récupérer.

C’est pourquoi nous avons construit la gestion des versions de fichiers. Chaque changement apporté à chaque fichier dans chaque espace de travail est préservé. Chaque version peut être consultée, comparée et restaurée d’un simple clic.

C’est Ctrl+Z pour l’IA.

10 février 2026 : le commit qui a tout changé

Le message du commit indique : “feat : ajouter la gestion des versions de fichiers VFS avec historique, restauration et retour en arrière des tâches.”

Derrière ce message se cache un système qui a fondamentalement changé la relation entre les utilisateurs et leurs agents IA. Avant la gestion des versions, donner à un agent IA un accès en écriture à vos fichiers nécessitait de la confiance. Après la gestion des versions, cela ne nécessite rien — car tout changement peut être annulé.

Cela compte plus que vous ne le pensez.

Pourquoi les agents IA ont besoin de contrôle de version

L’édition de fichiers par des humains est délibérée. Vous ouvrez un fichier, apportez des modifications, enregistrez. Si vous n’aimez pas le résultat, vous annulez. La boucle cognitive est serrée : changement, évaluation, conserver ou revenir en arrière.

L’édition de fichiers par un agent IA est différente. L’agent peut modifier cinq fichiers en une seule tâche. Il peut exécuter un travail en arrière-plan qui touche des fichiers pendant que vous dormez. Il peut interpréter “mettre à jour le rapport” comme “réécrire le rapport depuis le début.”

Sans gestion des versions, chaque opération de fichier IA est une porte à sens unique. L’original est perdu. Si vous n’aimez pas le résultat, vous devez reconstruire manuellement ce qui était là avant — en supposant que vous vous en souvenez.

Avec la gestion des versions, chaque opération de fichier IA est réversible. L’original est préservé. Si vous n’aimez pas le résultat, vous cliquez sur “restaurer” et il revient en moins d’une seconde.

Comment ça fonctionne

Snapshots automatiques. Chaque fois qu’un fichier est enregistré — par vous, par un agent IA, par une tâche en arrière-plan, par un téléchargement de fichier — la version précédente est automatiquement capturée. Aucune action manuelle requise. Pas d’étape “n’oubliez pas de valider”. Chaque enregistrement crée de l’historique.

Navigateur d’historique des versions. Ouvrez n’importe quel fichier et consultez son historique complet. Chaque version a un horodatage et un contexte : qui l’a modifiée (utilisateur vs. agent vs. tâche en arrière-plan), quand, et depuis quelle session. Vous pouvez voir la chronologie complète de l’évolution d’un fichier.

Restauration en un clic. Trouvez la version que vous voulez. Cliquez sur restaurer. Le fichier revient immédiatement. La restauration elle-même crée une nouvelle version (l’état actuel avant la restauration est préservé), donc la restauration est également réversible.

Retour en arrière des tâches. C’est la fonctionnalité dont nous sommes les plus fiers. Lorsqu’une tâche en arrière-plan modifie des fichiers, toutes ces modifications sont étiquetées avec l’ID de la tâche. Si la tâche a produit de mauvais résultats, vous pouvez revenir à l’état antérieur de tous les fichiers qu’elle a touchés en une seule action. Pas fichier par fichier — tout d’un coup.

Le détail d’implémentation qui compte

Les snapshots sont pris en utilisant un modèle de décorateur. Le fournisseur de stockage est enveloppé dans un VersionedStorageProvider qui intercepte chaque opération d’écriture et crée un snapshot avant que l’écriture ne soit terminée.

Cela signifie que la gestion des versions est invisible pour le reste du système. L’agent IA ne sait pas que les fichiers sont versionnés. Le point de téléchargement ne sait pas que les fichiers sont versionnés. Le moteur de tâches en arrière-plan ne sait pas que les fichiers sont versionnés. Ils écrivent tous des fichiers normalement, et la couche de gestion des versions capture tout.

C’était un choix de conception délibéré. Nous ne voulions pas que la gestion des versions soit une fonctionnalité que les développeurs devaient se souvenir d’utiliser. Nous voulions que ce soit une propriété du système de fichiers lui-même. Chaque fichier est versionné. Toujours. Pas d’option requise.

L’équation de confiance

Avant la gestion des versions, il y avait une équation de confiance implicite chaque fois qu’un utilisateur exécutait un agent IA :

Le bénéfice de cette tâche vaut-il le risque que l’agent gâche mes fichiers ?

Pour des fichiers importants — un rapport soigneusement rédigé, une base de code fonctionnelle, un ensemble de données curé — la réponse était souvent “non.” Les utilisateurs copiaient leurs fichiers dans un dossier séparé avant d’exécuter un agent. Ou ils évitaient de donner à l’agent un accès en écriture. Ou ils surveillaient chaque opération de fichier en temps réel, contrecarrant l’objectif d’exécution autonome.

La gestion des versions élimine cette équation. Le risque qu’un agent gâte des fichiers est nul, car tout changement peut être inversé instantanément. Les utilisateurs n’ont pas besoin de copier des fichiers avant d’exécuter des tâches. Ils n’ont pas besoin de surveiller l’agent au travail. Ils le laissent simplement fonctionner, examinent les résultats plus tard et reviennent sur tout ce qui n’est pas correct.

Cela déplace la relation de “délégation prudente” à “délégation confiante.” Exécutez la tâche. Vérifiez les résultats. Conservez ce qui est bon. Revenez sur ce qui ne l’est pas. Cela prend dix secondes au lieu de dix minutes de préparation avant la tâche.

La leçon plus large

Les agents IA sont puissants. Ils sont aussi imparfaits. La solution n’est pas de les rendre parfaits — c’est une norme impossible. La solution est de rendre leurs imperfections réversibles.

La gestion des versions de fichiers est un exemple d’un principe plus large : construire des filets de sécurité, pas des garde-fous. Les garde-fous empêchent l’IA d’agir. Les filets de sécurité permettent à l’IA d’agir librement tout en garantissant que les erreurs peuvent être corrigées.

L’exécution en bac à sable est un filet de sécurité (contient les dommages). La gestion des versions de fichiers est un filet de sécurité (préserve l’état précédent). La journalisation des événements est un filet de sécurité (crée des pistes de vérification). Chacun permet à l’IA d’être plus autonome en rendant l’autonomie moins risquée.

Les agents IA sur LikeClaw s’améliorent chaque semaine. Mais ils ne seront jamais parfaits. Et c’est bien — car avec la gestion des versions, ils n’ont pas besoin de l’être.