Comment exécuter les agents Claude Code pendant plus de 24 heures

Être capable d’exécuter de nombreux agents de codage en parallèle, c’est garantir des sessions de longue durée. Cela signifie des séances qui sont interrompues le moins possible. Par exemple, demander une contribution humaine, des autorisations, etc.

Les agents de codage frontalier sont de mieux en mieux capables de fonctionner sur de plus longues périodes, étant plus désireux d’atteindre les objectifs qu’ils reçoivent de la contribution humaine. Je le remarque particulièrement dans le dernier modèle Claude Fable et GPT-5.6.

Cependant, les agents eux-mêmes ne résolvent pas tout. Vous devez également disposer d’un harnais et d’une structure autour de votre codage qui garantissent que les agents peuvent fonctionner pendant de plus longues périodes. Dans cet article, je discuterai de :

• Comment créer un environnement dans lequel les agents peuvent fonctionner pendant de plus longues périodes
• Comment leur donner les autorisations dont ils ont besoin
• Comment garantir que les agents vérifient leur propre travail.

Pourquoi exécuter des agents de longue durée

Tout d’abord, j’aimerais expliquer pourquoi vous devriez suivre les conseils de cet article. Dans ce cas, il s’agit de savoir pourquoi vous devez exécuter des agents pendant une période plus longue. Vous pensez peut-être que vous souhaitez que les agents travaillent vite et accomplissent leur travail le plus rapidement possible. Bien sûr, dans une certaine mesure, vous voulez que les choses soient faites le plus rapidement possible, mais il y a aussi un compromis ici avec la quantité d’interaction qu’un humain doit avoir avec l’agent pour faire le travail.

Après la sortie des agents de codage, et surtout après qu’ils soient devenus très puissants, après la sortie de Claude Opus 4.5, le goulot d’étranglement au sein du codage est devenu le temps de révision humaine ; c’est-à-dire que ce n’est pas réellement l’implémentation du code qui prend du temps ; c’est plutôt examiner les résultats du code, vérifier qu’il est implémenté correctement et selon les spécifications, cela prend du temps. Ainsi, puisqu’il s’agit du goulot d’étranglement, vous souhaitez minimiser le temps que vous consacrez à la révision, c’est pourquoi vous souhaitez que les agents fonctionnent pendant des périodes plus longues, en mettant tout en œuvre et en les révisant eux-mêmes avant de les confier à l’humain.

Cela minimise le temps qu’un humain doit passer à vérifier une tâche, ce qui est idéal car c’est le goulot d’étranglement actuel dans la programmation.

Expliqué simplement :

Vous voulez des agents qui fonctionnent depuis longtemps, car la révision humaine est désormais le goulot d’étranglement, et vous souhaitez minimiser le temps que vous consacrez à la révision humaine pour accomplir autant de travail que possible.

Comment exécuter des agents pendant plus de 24 heures

Je vais maintenant passer à des techniques et à des conseils plus spécifiques sur la manière d’exécuter des agents sur de plus longues périodes. En tant qu’aperçu de haut niveau, je couvrirai ces techniques et conseils.

• Donnez toutes les autorisations aux agents
• Donnez aux agents la possibilité de vérifier leur propre travail
• Demander aux agents de réviser le code (Codex)
• Exécuter des agents à distance

Autorisations

La première chose par laquelle vous pouvez commencer tout de suite est de vous assurer que les agents disposent de toutes les autorisations dont ils ont besoin. Si un agent doit cesser de demander des autorisations, vous perdez beaucoup de temps et, dans presque tous les cas, c’est simplement quelque chose que vous acceptez de toute façon. Il existe de nombreuses façons de procéder, et vous pouvez activer le mode automatique ou ignorer toutes les autorisations, qui sont des paramètres disponibles dans Codex et Claude Code. Il peut être intéressant de noter que vous devez fonctionner en mode sandbox afin de protéger votre ordinateur et vos données et de vous assurer que rien n’est supprimé définitivement.

Je pense qu’il convient également de savoir qu’OpenAI a récemment admis avoir eu des situations dans lesquelles le dernier modèle GPT avait supprimé un certain nombre de fichiers des ordinateurs des utilisateurs dans des circonstances très spécifiques. Ceci est bien sûr très rare et ne vous arrivera probablement jamais, mais bien sûr, les conséquences, si cela se produit, peuvent être assez graves.

Il existe de nombreuses façons de s’en protéger. La première consiste, bien sûr, à exécuter les agents dans un bac à sable afin qu’ils ne puissent pas supprimer des éléments en dehors de leur propre espace de travail où ils travaillent ou sont actifs. Une autre chose est de tout sauvegarder sur votre ordinateur. Vous devez bien sûr disposer de tout votre code et travailler dans GitHub si possible. Ceci est bénéfique à la fois pour le stockage sécurisé et pour le versioning, ce qui peut être très utile. Et globalement, effectuez des sauvegardes sur votre ordinateur, par exemple en utilisant Time Machine sur Mac. Cela vous protégera de telles situations.

Vérifier le travail

Un autre point très important est de garantir que les agents puissent vérifier leur propre travail. C’est un sujet que j’ai déjà abordé dans plusieurs autres articles, mais tout dépend de la façon dont vous décrivez une tâche à votre agent et des outils que vous donnez aux agents.

Lorsque vous décrivez une tâche à l’agent, vous devez vous assurer de donner des instructions aussi détaillées que possible, en mentionnant réellement ce que vous souhaitez réaliser, mais surtout, vous devez dire à l’agent comment savoir quand il a terminé son travail. Et la meilleure façon d’y parvenir est généralement d’indiquer à l’agent comment tester l’implémentation.

Pour donner un exemple, disons que vous souhaitez mettre en œuvre une conception particulière qui vous a été confiée. Dans ce cas, vous devez indiquer à l’agent que la conception doit être implémentée exactement telle quelle et que l’agent doit vérifier le travail en prenant des captures d’écran de la conception et des captures d’écran de sa propre implémentation, en les comparant et en s’assurant qu’elles sont égales. De plus, vous devez également lui dire que s’il y a des écarts entre la conception et ce qui est mis en œuvre, il doit vous en informer afin que vous puissiez prendre des décisions.

La raison pour laquelle vous avez besoin de cette dernière partie est que les conceptions comportent souvent des parties techniquement irréalisables compte tenu de votre base de code. Et il est très difficile pour un concepteur de prendre tout cela en compte, donc dans certaines situations, il y aura des écarts que vous devrez prendre en compte et gérer. Mais vous devez faire en sorte que votre agent de codage vous en informe s’ils apparaissent, et sinon, cela devrait être exactement égal. Vous donnez ensuite au navigateur de l’agent l’accès, par exemple à Chrome, afin qu’il puisse ouvrir à la fois la conception et son implémentation dans Chrome, prendre des captures d’écran et vérifier son propre travail.

Vous pouvez appliquer une philosophie similaire à pratiquement toutes les autres tâches de programmation. Décrivez une tâche en détail, à quoi penser et comment l’agent doit vérifier son propre travail, par exemple en prenant des captures d’écran ou en exécutant une suite de tests, etc.

Révision du code agent

La dernière section dans laquelle j’explique comment vérifier le travail est très utile, mais elle peut aussi être un peu difficile à mettre en œuvre car elle vous oblige à inviter les agents d’une manière spécifique et à leur donner accès à tous les outils dont ils ont besoin. La section suivante, avec une révision du code agent, est beaucoup plus simple.

Fondamentalement, vous devez configurer un moyen permettant aux agents de réviser leur propre code afin que vous n’ayez pas à effectuer la révision humaine. À mon avis, si vous faites cela correctement, vous n’avez presque pas besoin de procéder à une révision humaine du code, à moins que ce ne soit des parties très, très critiques de vos applications que vous ne pouvez pas vous permettre de vous tromper. La raison en est que je pense que les agents de codage sont devenus si doués pour réviser le code qu’ils éliminent pratiquement tous les bogues causés par le nouveau code mis en production.

À mon avis, le meilleur agent de révision est le Codex. Vous pouvez effectuer une révision avec celui-ci de 2 manières. Premièrement, vous pouvez utiliser l’implémentation de révision GitHub dont dispose le Codex lui-même, où vous l’activez, et vous marquez simplement Codex dans un PR, et il viendra automatiquement réviser le code. La deuxième façon consiste à l’exécuter via la CLI, où vous pouvez essentiellement déclencher le Codex pour qu’il exécute une révision sur une branche et la compare à une autre branche. Il vous suffit donc de le pointer vers 2 succursales et il effectue un examen pour vous. J’utilise généralement la deuxième méthode car, d’après mon expérience, elle est plus rapide et il y a souvent un retard avec la révision git où le Codex est balisé sur GitHub.

Cela vous fera gagner énormément de temps et vous pourrez mettre beaucoup plus de code en production.

Agents exécutés à distance

Une dernière chose que je voudrais mentionner est que pour avoir des agents qui fonctionnent à long terme, vous devez avoir des agents qui s’exécutent à distance. Cela signifie essentiellement que les agents ne seront pas interrompus lorsque vous fermez votre ordinateur. Il y a des avantages et des inconvénients à effectuer cette configuration. L’un des avantages de l’exécution d’agents localement sur votre ordinateur est, bien entendu, que vous y avez un accès complet. Vous pouvez exécuter, vous pouvez facilement voir toutes les interactions du navigateur effectuées par les agents ou examiner facilement ce que font les agents. Et aussi, c’est juste une configuration plus simple. L’exécution des agents localement est plus simple que leur exécution à distance. Cependant, exécuter des agents à distance présente également des avantages très importants.

Si vous les exécutez localement, vous risquez qu’ils soient interrompus. Par exemple, si vous fermez votre ordinateur lorsque vous rentrez du travail ou si vous partez en voyage et que vous devez fermer votre ordinateur, les agents seront coupés. Désormais, sur Mac, par exemple, vous pouvez désactiver la veille si vous fermez le couvercle de l’ordinateur, mais d’après mon expérience, cela rend l’ordinateur très chaud, et je ne recommande pas de le faire. Cela n’a pas très bien fonctionné lorsque je l’ai essayé.

Cependant, si vous avez des agents exécutés à distance, ils ne seront bien sûr pas interrompus car ils s’exécutent soit dans le cloud, soit sur un autre ordinateur, qui est toujours allumé et jamais fermé. L’inconvénient est, bien sûr, que vous avez moins d’aperçu de ce que font exactement les agents, et cela peut être un peu difficile à mettre en place, même si vous pouvez utiliser Claude Code ou des agents de codage pour le configurer assez simplement.

Pour ma configuration, je dispose d’un ordinateur puissant que j’utilise en déplacement et sur lequel j’exécute la plupart de mes agents. Cependant, j’ai également un ordinateur secondaire sur lequel mes robots fonctionnent, mes robots OpenClaw, afin qu’ils puissent travailler à tout moment, et je peux également lancer des sessions Claude Code ou Codex sur cet ordinateur afin qu’elles s’exécutent indéfiniment si je veux que les tâches s’exécutent sans être interrompues. Cela peut être très utile. Une dernière alternative consiste à l’exécuter quelque part dans le cloud, mais cela présente également des inconvénients. Tout d’abord, vous devez stocker des documents ou des secrets dans le cloud, ce qui peut être risqué et que je veux personnellement éviter. Et oui, c’est aussi un peu compliqué à mettre en place, en gros.

Conclusion

Dans cet article, j’ai expliqué comment exécuter des agents pendant des périodes plus longues. J’ai expliqué pourquoi c’est important, en soulignant comment cela vous permet d’effectuer plus de travail en tant qu’ingénieur. De plus, j’ai abordé des techniques spécifiques permettant aux agents de fonctionner pendant de longues périodes, notamment en leur accordant les autorisations dont ils ont besoin, en leur expliquant comment vérifier leur propre travail, comment effectuer une révision du code agent et comment exécuter des agents à distance pour garantir qu’ils ne sont jamais interrompus. Je pense que toutes ces techniques sont très importantes et que vous devriez commencer à toutes les mettre en œuvre pour garantir que vos agents soient capables de fonctionner de manière autonome le plus longtemps possible jusqu’à ce qu’ils terminent leur travail. De plus, je pense également que l’exécution d’agents à distance sera de plus en plus populaire à l’avenir, étant donné que cela n’a pas vraiment de sens de tout exécuter sur votre ordinateur local, étant donné qu’il sera inévitablement arrêté à certains moments, ce qui interrompra vos agents. C’est donc certainement une direction à laquelle il faut prêter attention.

👋 Entrer en contact

👉 Mon eBook et mon webinaire gratuits :

🚀 10x votre ingénierie avec les LLM (cours gratuit par e-mail de 3 jours)

📚 Obtenez mon ebook gratuit sur les modèles de langage de vision

💻 Mon webinaire sur les modèles de langage de vision

👉 Retrouvez-moi sur les réseaux sociaux :

💌 Sous-pile

🔗 LinkedIn

🐦 X/Twitter