Dans la nuit du 9 au 10 novembre, vers 23 h 30, trois équipes d'agents travaillaient sur la même page de mon cockpit. Chacune avait une petite tâche : corriger les défauts d'affichage d'un écran. Elles se sont arrêtées sans que rien n'ait atterri. Elles avaient passé leur temps à chercher le code, pas à le changer.
Ce billet raconte ce qu'on a construit cette semaine pour que des agents travaillent ensemble sans se marcher dessus, et surtout ce qui a cassé en route. Je montre les échecs avec leurs chiffres, parce que c'est là que j'ai appris quelque chose. Toutes les heures sont celles de Montréal.
Le problème : la vérification arrivait après le code
Avant, une session d'agent prenait un ticket, écrivait le code, puis découvrait au moment d'ouvrir sa pull request qu'une autre session avait touché les mêmes fichiers. Chacune avait raison seule. Ensemble, elles passaient au rouge.
On a mesuré, du 26 octobre au 9 novembre, sur 10 dépôts actifs et 1 782 pull requests. 826 d'entre elles (46 %) partageaient un fichier avec une autre PR ouverte en même temps. 312 ouvertures de PR ont été refusées pour chevauchement, alors que le code était déjà écrit. 109 PR (6 %) ont été fermées sans fusionner.
Le détail le plus utile était ailleurs : parmi les paires qui se chevauchaient, 65 % ne partageaient que des « fichiers collecteurs ». Ce sont les fichiers où tout le monde ajoute une ligne : les traductions, les exports d'un paquet, la doc générée, les workflows. Si on les réserve, tout le travail fait la queue. On y revient plus bas.
Trois rôles, et un seul qui décide
La décision tient dans un ADR, accepté le 9 novembre. Trois rôles :
- le planificateur, c'est Mouloud, notre CTO (un agent) : il valide les tâches, les découpe, tranche ce que le code ne sait pas trancher ;
- le coordinateur est du code sans aucun modèle dedans, et il n'y en a qu'un. Il attribue les tâches, tient les réservations et refuse ce qui casse les règles. Il ne prend aucune décision d'architecture ;
- une session, n'importe quel agent : elle reçoit un bail sur une tâche, fait un changement borné et livre un diff vérifiable.
Pourquoi pas un modèle comme coordinateur ? Parce qu'à cet endroit on a besoin d'une transaction, et un modèle n'est pas déterministe. Pourquoi pas une discussion libre entre sessions ? Ce n'est ni durable, ni vérifiable, et ça coûte cher en tokens. Les messages entre sessions sont une liste fermée de six types (« existe déjà », « extension de périmètre », « bloqué »…), toujours rattachés à une tâche, et un message n'est jamais une décision.
Le registre est une base SQLite locale, sur le Mac. Elle ne contient jamais de code, seulement des pointeurs vers Git. Quand elle et GitHub ne sont pas d'accord sur un fait, GitHub gagne.
- Le CTO valide (taille S ou M, tours)Une tâche naît « proposée ». Elle doit avoir une taille (S ou M), un plafond de tours (60 au plus pour S, 120 pour M) et au moins une ligne « fini quand ». Une tâche L est refusée avec ce message : découpe-la, une tâche par écran, composant ou sujet. Personne ne peut la prendre avant la validation du CTO.
- Un bail (un seul gagne)La session réclame la tâche. La réclamation est atomique : sur plusieurs demandes simultanées, une seule gagne. Elle reçoit un bail, avec une échéance et un token.
- Un worktree (refusé sans bail)L'outil qui crée l'espace de travail refuse s'il n'y a pas de bail actif sur la tâche.
- Des commits (vérifiés au périmètre)Chaque commit est comparé au périmètre accordé. Un fichier hors périmètre est refusé au commit, pas après la PR.
- L'atterrissage (un à la fois)Il refuse un bail expiré, un token périmé, un diff hors périmètre, un rebase raté, des contrôles rouges. Il ne lance que les contrôles rapides : typage, lint, tests.
- Fait (preuve visuelle par vague)La tâche est sur le main local. La preuve visuelle (serveur de dev et audit des pages) se fait une seule fois, quand toute la vague a atterri.
Une tâche n'est pas un ticket. Le ticket suit le besoin ; la tâche, c'est ce qui tourne. Un ticket peut donner plusieurs tâches, et une tâche peut servir plusieurs tickets.
Le verrou : un bail, un battement, un token
Une réservation que rien ne fait respecter n'est qu'un souhait. Le verrou du coordinateur repose sur trois pièces simples.
Le bail a une échéance. Pendant notre dernière vague, il courait trente minutes. Le battement le prolonge : toutes les deux minutes, le lanceur de la session renouvelle le bail. Le token (on dit « fencing token ») est un numéro qui augmente à chaque nouveau bail. Si une session s'endort et que son bail expire, la tâche revient libre, une autre session peut la prendre avec un token plus grand, et l'ancien token ne peut plus rien livrer.
- Réclamer (une seule gagne)Plusieurs sessions demandent la même tâche au même moment. La base la donne à une seule, dans une transaction.
- Bail et token n (échéance à 30 min)La session reçoit le bail et le token n. Elle travaille dans son worktree.
- Battement (le lanceur, hors du modèle)Toutes les deux minutes, le programme qui fait tourner la session renouvelle le bail. Ce n'est pas l'agent qui s'en souvient : c'est le lanceur, tant que le processus vit.
- Le bail expire (la tâche redevient libre)Plus de battement : à l'échéance, le service marque le bail expiré et remet la tâche à prendre. Il vérifie toutes les 30 secondes et à chaque requête.
- Bail et token n+1 (une autre session)Une nouvelle session reprend la tâche, avec un token plus grand.
- Livrer avec n (refusé)L'ancienne session se réveille et veut livrer avec le token n. Refusé : ce token n'est plus le bon.
Ce schéma n'était pas vrai du premier coup. Le 9 novembre vers 22 h 45, la première vague (on l'appelle cockpit-1) a montré deux défauts. Une tâche dont le bail avait expiré restait marquée « en cours ». Et les équipes n'envoyaient pas leur battement : la consigne leur disait de le faire, elles ne le faisaient pas. Une session n'a renouvelé son bail qu'une seule fois en 150 tours. La correction a été de sortir le battement du modèle et de le confier au lanceur. Une règle qu'un agent doit se rappeler n'est pas une règle.
Le périmètre, tenu à quatre endroits
Le bail dit qui travaille. Le périmètre dit sur quoi. Chaque tâche reçoit une liste de chemins, et quatre endroits refusent ce qui en sort. Aucun de ces endroits n'est à l'intérieur d'un agent.
- 1Le worktreeL'outil qui le crée refuse s'il n'y a pas de bail actif.pas de bail, pas d'espace de travail
- 2Le commitLe hook de commit refuse un fichier indexé hors du périmètre.refus avant même le commit
- 3Le pushLe hook de push refuse des commits hors périmètre, ou venus d'un bail expiré.rien ne sort de la machine
- 4La fusionEn local, l'atterrissage refuse un diff hors périmètre ; sur GitHub, un statut exigé posé par le coordinateur.la dernière porte
- —Les fichiers collecteursJamais réservés : traductions, exports d'un paquet, doc générée, workflows.accordés à plusieurs tâches à la fois · ne bloquent jamais un chemin plus large
Une précision honnête : aujourd'hui, un seul dépôt est sous coordination, les outils locaux du cockpit. Pour lui, le commit et l'atterrissage local font le travail. Le hook de push et le statut exigé sur GitHub existent, mais aucun dépôt GitHub n'est encore sous coordination : on les branchera un par un.
La règle des fichiers collecteurs est écrite dans l'ADR. Elle a quand même cassé au premier essai : le coordinateur a refusé deux tâches parce qu'elles touchaient toutes les deux le dossier des traductions du cockpit. Il répondait « périmètre déjà pris ». On l'a vu en vrai, pendant la vague, et corrigé le jour même : le dossier d'un motif collecteur est maintenant accordé à plusieurs tâches vivantes.
Le même jour, une équipe a eu besoin d'un fichier hors de son périmètre. Elle ne l'a pas touché. Elle a publié une demande d'extension de périmètre, Mouloud l'a tranché, et le besoin est devenu une tâche à part (la tâche 5 de la vague). C'est le comportement voulu : un travail hors périmètre se suspend, il ne s'étale pas.
Trois tests sur la même page
Le cockpit a un audit qui ouvre chaque écran, en sombre et en clair, en français et en anglais, à plusieurs largeurs, et note ce qui déborde. Le 9 novembre au soir, après une montée de version de notre bibliothèque d'interface, il relevait 36 défauts sur trois écrans. Je ne sais pas s'ils dataient d'avant la montée. C'était un bon terrain d'essai pour les équipes.
Test 1, une seule grosse tâche. Une équipe a reçu tout l'audit. Elle a épuisé ses 150 tours : 125 commandes shell, 35 lectures de fichiers, 3 modifications. Rien n'a atterri. Il reste un patch partiel de 34 lignes.
Test 2, trois petites tâches sans analyse. On a découpé l'audit en trois tâches S, une par écran. Rien n'a atterri non plus. Chaque équipe a passé de 25 à 39 de ses quelque 55 appels à lire des fichiers. Zéro appel à codegraph, notre index du code, pourtant fourni.
Test 3, trois tâches avec l'analyse. Avant de lancer, un agent en lecture seule a écrit une carte : chaque défaut, son fichier et sa ligne, et le correctif probable. Les équipes ont fait leur première modification de code entre le 13ᵉ et le 17ᵉ appel. Puis elles ont épuisé leurs 50 tours dans la boucle de preuve : relancer le serveur de dev, refaire l'audit complet, encore et encore. Mouloud a fait atterrir les trois tâches, contrôles verts, aucun conflit. L'audit est passé de 36 à 20 défauts.
Les 20 restants venaient de deux barres d'onglets, trouvées en mesurant la page rendue avec un script. Deux tâches de plus, et l'audit est passé au vert : 42 routes, 19 écrans propres, sombre et clair, français et anglais.
La vague suivante, cockpit-2. On a appliqué les leçons : l'analyse dans le brief, le CTO qui valide et dimensionne, et plus de preuve visuelle dans les sessions. Quatre tâches en parallèle (S, M, M, S), de 2 h 48 à 3 h 30 du matin. Trois ont atterri seules. La quatrième, l'écran Alertes, a épuisé ses tours, puis a atterri après une reprise de 30 tours.
Le test 1 montre où passe le temps quand une tâche est trop grosse :
Et même dans la vague qui a marché, les équipes n'utilisaient presque pas l'index du code :
Reste le coût. Je ne donne pas de montants ici ; je les ramène au premier test, qui vaut 100.
La preuve visuelle unique de cockpit-2 a servi tout de suite. L'outil qui devait la faire a échoué pour des raisons d'environnement, alors Mouloud l'a faite à la main, sur une copie des outils. Elle a trouvé un vrai défaut : l'écran Alertes répondait une erreur 500, parce que les lignes lues par le module SQLite de Node n'ont pas de prototype. Corrigé, avec un test. Audit final vert : 46 routes, 19 écrans.
Ce que ces tests nous ont appris
- Le CTO valide et découpe chaque tâcheUne tâche trop grosse ne se rattrape pas en cours de route. La taille L est refusée par le coordinateur.
- L'analyse vient avant la sessionLe fichier et la ligne, écrits avant le lancement. Sans elle, les agents cherchent ; avec elle, ils corrigent.
- La preuve visuelle, une fois par vagueUn serveur de dev et un audit complet dans chaque session, c'est trop lourd. On le fait une fois, après l'intégration.
- Finir en local, pousser une foisLes contrôles tournent sur la machine ; un seul push, quand tout est vert.
- Lire la raison d'un rouge avant d'envoyer un gros modèleUne PR verte sur le Mac et rouge dans la CI manquait d'une identité Git, pas d'intelligence.
- Une règle qu'un agent doit se rappeler n'est pas une règleLe battement du bail, l'arrêt d'une équipe, le compte des appels : c'est le lanceur qui les fait.
Trois défauts de notre propre outillage sont aussi sortis pendant ces tests. L'arrêt d'une équipe arrêtait son service, mais pas le processus de l'agent : il a fallu le tuer à la main. Il arrête maintenant tout le groupe de processus. L'interrupteur des équipes était partagé avec un autre automate : pour lancer les équipes, il fallait rallumer l'autre dix secondes. Les équipes ont maintenant le leur. Et un ajout aux briefs a échoué sans bruit, à cause d'une syntaxe de bash que zsh ne connaît pas ; le premier essai du test 3 est parti sans la carte, on l'a arrêté et relancé.
Les crons : l'horloge contre l'événement
Le Mac fait tourner des tâches planifiées : synchroniser le tableau des tickets, nettoyer les worktrees, réindexer le code, surveiller le reste. Le 10 novembre, on a relu les 20 derniers passages de chacune. La plupart répondaient « rien à faire ».
Sur l'horloge, avant
- Nettoyage des worktrees : toutes les heures, 391 s, presque toujours « gardé »
- Synchro du tableau : toutes les heures, 270 s
- Cache du tableau : toutes les 20 min, 120 s, 15 erreurs
- Mise à jour des outils : toutes les 15 min, presque toujours « déjà à jour »
- Mise à jour des plugins : toutes les 30 min, « à jour » 99 % du temps
- Export de l'architecture : deux fois par heure, « outil pas encore sur main »
- Export des trains : chaque minute, rien quand aucun train ne roule
- Index du code : toutes les 30 min, 21 dépôts relus
Sur un événement, après
- Nettoyage des worktrees : une fois par nuit
- Synchro du tableau : après chaque fusion, à la fin d'une session, et une fois par nuit
- Cache du tableau : à la demande, seulement ce qui a changé
- Outils et plugins : après une fusion de l'outillage, et au démarrage d'une session
- Export des trains : quand l'état d'un train change
- Export de l'architecture : retiré des crons
- Index du code : toutes les 2 heures
- Surveillance : locale toutes les 15 min, GitHub au plus une fois par heure
Le principe est simple : la base locale d'abord. On lit GitHub seulement pour ce qui a changé, au moment où on en a besoin. Le cache du tableau, par exemple, ne relit plus tout : il demande ce qui a bougé depuis sa dernière lecture.
Une alerte de 18 h 30, traitée à 0 h 45
Le 9 novembre à 18 h 20, Mouloud a remis la ligne du cron sync-db (il synchronise nos bases locales, et les copies de sauvegarde se font pendant son passage) dans le bloc géré de la crontab. Mais le script n'avait pas le droit d'exécution dans Git. Tous les passages ont échoué avec le code de sortie 126, pendant environ six heures et demie.
Le watchdog l'a vu. À 18 h 30, il a levé une alerte CRITIQUE, sous la forme d'une notification sur le bureau du Mac. Personne ne l'a lue. À 0 h 45, Mouloud a rétabli le cron avec l'ancienne ligne, a lancé une synchro à la main (sortie 0), puis a ajouté le bit d'exécution et une garde : tout outil lancé par un cron doit être exécutable.
C'était notre erreur, et l'outil l'avait attrapée. Ce qui a manqué, c'est un endroit où l'alerte reste jusqu'à ce que quelqu'un s'en occupe. Une notification, ça passe et ça disparaît.
Depuis le 10 novembre, toutes les alertes vont dans une seule table de notre base d'opérations, et plus aucune notification n'est envoyée, quelle que soit la gravité. Un test refuse le retour d'une notification. Les sessions lisent les alertes ouvertes en premier au démarrage, Mouloud à chaque point d'étape, et le cockpit les montre avec ce qui a été fait pour chacune.
- Levée (watchdog, trains)Le watchdog, le contrôleur des trains et l'automate qui débloque les PR écrivent une ligne dans la table.
- Ouverte (lue au démarrage)La même alerte qui revient ne fait pas une nouvelle ligne : son compte monte, avec l'heure du dernier passage. Elle s'affiche en tête de chaque session et dans le cockpit.
- Prise en charge (qui, et une note)Quelqu'un la prend, et écrit ce qu'il a compris. Pour sync-db, la note aurait été : le script n'est pas exécutable.
- Résolue (avec une preuve)On la ferme avec une preuve. Pour sync-db : une synchro à la main, sortie 0, et la garde ajoutée.
- Purgée (7 jours après)Sept jours après la prise en charge, la ligne est purgée. Une alerte ouverte ne l'est jamais.
L'incident de sync-db est arrivé avant cette table. Le schéma montre ce qu'il serait devenu aujourd'hui, pas ce qui s'est passé ce soir-là.
Deux autres trous sont sortis la même semaine. Une PR de notre outillage était verte sur le Mac et rouge dans la CI : un test faisait un rebase dans un dépôt temporaire, et Git refusait faute d'identité. Le Mac en a une, la machine de la CI non. Le correctif prévu est de faire tourner les tests du pre-push dans un environnement vidé, comme la CI, sans Docker. Et la suite de tests de cet outillage prend 263,6 secondes pour 58 fichiers, dont 75 pour un seul : on la fera tourner en parallèle, et seulement les tests touchés dans la boucle locale.
La CI : les dépôts privés sur le Mac, les publics sur GitHub
Les dépôts publics ont la CI de GitHub sans frais. Les dépôts privés consomment des minutes. Le Mac fait déjà tourner les agents (pas de Mac, pas d'agents), donc on y a mis un runner pour les dépôts privés, et seulement pour eux.
Privés, sur le Mac
- Notre outillage : lint, tests et scan de sécurité sur le Mac, preuve faite
- Avant : environ 200 minutes par jour pour ce dépôt, depuis le 9 novembre
- Le scan en double à chaque push est retiré
- Le dépôt des tickets est descendu à 5 minutes par jour
- Le runner se met à jour seul
Publics, sur GitHub
- Les machines de GitHub ne coûtent rien à un dépôt public
- Jamais sur le Mac : une PR venue d'une copie y ferait tourner son code
- Rien ne change pour eux : ubuntu par défaut
Pas encore prouvé
- Que les minutes facturées s'arrêtent : à montrer avant et après
- Une alerte quand la version du runner prend du retard : en revue
- Trois autres dépôts privés, prêts, attendent un réglage de l'organisation
- Un workflow d'infrastructure qui porte des secrets reste sur GitHub, par décision
Le groupe de runners autorise les dépôts par leur nom, jamais « tous ». C'est la règle qui protège le Mac.
L'outil qu'on fournit, et que personne n'utilise
Le chiffre qui me gêne le plus de cette semaine, c'est zéro. Dans les trois premiers tests, les équipes ont fait zéro appel à codegraph, l'index de notre code, alors qu'il était fourni et que les règles l'exigeaient. Dans la vague cockpit-2, une seule session s'en est servie, quatre fois. Un sous-agent observé à part a fait 2 appels pour une quinzaine de recherches à la main.
On a trouvé une raison possible. RTK, l'outil qui résume les sorties des commandes pour économiser des tokens, avait coupé 77 % de la sortie des recherches, sur 11 307 appels. Un agent qui reçoit une recherche tronquée finit par relire des fichiers entiers. Depuis le 10 novembre, les commandes de recherche et de lecture passent sans filtre. Ce n'est pas une explication prouvée : le lanceur compte maintenant les appels à codegraph et aux recherches à chaque session, et on verra.
Ce que d'autres ont construit
En faisant ce travail, j'ai cherché ce qui existe. Le domaine a convergé cette année sur les mêmes idées que nous : des baux qui expirent, des réservations de périmètre, un accès par MCP. J'ai revérifié l'état de chaque projet le 10 novembre.
- dibs (MIT, 2 étoiles, dernier push le 14 octobre) : des réservations de fichiers avec une durée de vie, et des hooks. Ses hooks laissent passer quand l'outil ne répond pas, et c'est voulu : il préfère ne jamais bloquer un travail légitime. Nous avons fait le choix inverse : sans coordinateur, aucun nouveau bail n'est donné.
- Coordinaut (MIT, 0 étoile, dernier push le 28 juin) : propriété des tâches, verrous de fichiers, baux. Une idée à lire, plus un projet actif.
- synapse-channel (AGPL-3.0, 1 étoile, actif).
- Foremerge (Apache-2.0, 434 étoiles, actif) : le candidat sérieux. Les agents annoncent leur intention avant d'écrire, avec des périmètres sémantiques : des symboles, des API, des schémas, pas seulement des chemins. Il se présente lui-même comme une première version, locale, sans résultats de mesure publiés.
- Les équipes d'agents de Claude Code : intégrées à l'outil, avec une liste de tâches partagée, des réclamations protégées par un verrou et des messages entre coéquipiers.
- Des orchestrateurs pour lancer des agents en parallèle, comme Agent Orchestrator (Apache-2.0, 14 373 étoiles).
La recherche dit la même chose sous un autre angle. AgenticFlict rassemble les conflits de fusion des pull requests écrites par des agents. Passes Alone, Fails Together mesure les conflits sémantiques : deux changements corrects chacun, faux ensemble. AgentRoom fait travailler les agents dans un espace partagé, sans branches.
Ce qui est à nous
- Le périmètre tenu à quatre endroits, pas seulement conseillé
- Les fichiers collecteurs jamais réservés
- Le CTO valide et dimensionne avant toute session
- Tout en local, sans service distant
- Des vagues mesurées
Ce que d'autres font mieux
- Foremerge voit les conflits d'intention, nous ne voyons que des chemins
- Les équipes de Claude Code sont intégrées, sans service à faire tourner
- Les orchestrateurs ont une vraie interface pour suivre les agents
Pas prouvé chez nous
- Le lien entre chevauchement et travail refait, en temps ou en argent
- La qualité de nos analyses et leur coût
- Le tout avec un autre agent que Claude Code
Ce que nous avons décidé : on ne construit plus rien de neuf sur notre coordinateur, à part des correctifs, tant que la comparaison n'est pas faite pour de vrai, pièce par pièce : garder, remplacer, ou envelopper un outil existant. Et à la prochaine vague, une tâche tournera avec codegraph et un serveur de langage, une autre avec codegraph seul, et on gardera ce qui gagne.
Ce que je garde
Je n'ai rien inventé de très neuf. D'autres font des baux, des réservations, des files de tâches, et certains voient des conflits que nous ne voyons pas. Ce qui a compté pour nous, c'est de mesurer chaque vague et de regarder les échecs en face. Trois tests ratés nous ont appris plus que la vague qui a marché.
Une alerte qui disparaît n'a jamais existé. Une règle qu'un agent doit se rappeler non plus. Ce qui tient, c'est ce qu'un programme vérifie, à un endroit où on le voit.
des pull requests partageaient un fichier avec une autre PR ouverte en même temps
46 %
ouvertures de PR refusées pour chevauchement, le code déjà écrit
312
