L'IA code vite. Les systèmes distribués, elle ne les comprend pas encore.

L'IA code vite. Les systèmes distribués, elle ne les comprend pas encore.

Depuis que l'IA écrit une bonne partie de notre code, on n'entend presque plus parler de systèmes distribués. Deux études publiées en 2026 montrent que ce n'est pas parce que le problème a disparu. C'est même là que les meilleurs modèles décrochent le plus.

Sur mon fil, tout tourne autour de la vitesse : une app en un week-end, un agent qui livre une feature pendant le café, des démos de vibe coding. Les mots consensus, réplication, partition réseau ou idempotence ont quasiment disparu de la conversation.

J'ai voulu savoir si c'était justifié. La réponse courte: non. La réponse longue est expliquée dans cette article.

Pourquoi on n'en parle plus

Le sujet n'a pas disparu, il est devenu invisible. Trois raisons expliquent ce silence.

  • Les projets mis en avant sont petits. Un frontend, une API, une base de données. Un monolithe sur une plateforme managée suffit et personne n'a besoin de penser à la réplication.
  • Le cloud cache la complexité. Files de messages, bases distribuées et orchestration sont consommées en service. Le développeur ne voit plus ce qui se passe quand un nœud tombe.
  • L'IA brille sur le code local. Une fonction, un composant, un endpoint : elle les écrit très bien. Une race condition entre trois services ne se voit pas en lisant le code. Elle apparaît à l'exécution, dans un ordre d'événements précis.

Cette dernière raison est la plus importante. Les benchmarks qui font les gros titres, comme SWE-bench, mesurent surtout des bugs qu'on peut localiser dans un seul processus. Ils disent peu de choses sur ce qui arrive quand le bug vit entre les machines.

Sur les bugs distribués les plus durs, le meilleur modèle testé en résout à peine la moitié. C'est le résultat principal de DDBench, un benchmark publié par une équipe de l'University of Southern California.

Les auteurs ont réuni 60 bugs historiques tirés de 13 systèmes open source: bases clé-valeur, bibliothèques de consensus, systèmes de messagerie, service meshes. Le code est en Go, C++, Java, Erlang et Rust. Les bugs sont classés en trois niveaux selon le raisonnement qu'ils demandent :

  • Tier 1 (31 bugs) : il faut raisonner sur l'état du protocole et sur des exécutions concurrentes.
  • Tier 2 (15 bugs) : l'état est réparti sur plusieurs processus.
  • Tier 3 (14 bugs) : le bug se localise dans un seul processus, à partir d'une entrée précise.

La plus grosse famille, à 31,7 %, regroupe les pannes de protocole et de reprise : élection d'un coordinateur, reprise après crash. Viennent ensuite les problèmes de concurrence et les violations de réplication ou de cohérence, à 18,3 % chacune.

Dix modèles ont été testés avec le même agent, dans deux conditions. Soit l'agent reçoit seulement le dépôt et une description du symptôme. Soit il reçoit aussi un petit paquet de contexte de debug : logs, traces, état à l'exécution.

[embed: node/d478e6a3-1d07]

Trois choses m'ont frappé.

Ce benchmark sépare vraiment les modèles. Sur SWE-bench Verified, les six modèles qui ont un score publié tiennent dans un écart de 7 points. Sur le tier 1 de DDBench, cet écart monte à 42 points. Le raisonnement distribué est une compétence à part, que les benchmarks classiques mesurent mal.

Le contexte d'exécution change tout. Avec des logs et des traces, le taux de réussite moyen passe de 31 % à 50 %. Le gain diminue quand le bug devient plus local : +19 points sur le tier 1, +9 points seulement sur le tier 3. Les modèles forts y gagnent surtout en efficacité : Claude Opus 4.6 consomme 61 % de tokens en moins.

Le contexte peut aussi tromper. Quand le symptôme observé est loin de la cause, même un contexte fidèle peut ancrer un bon modèle sur la mauvaise couche. Les auteurs appellent ça la « distance d'abstraction » et l'illustrent avec des bugs réels de ZooKeeper et de Raft.

Les modèles savent écrire une spécification formelle valide mais elle décrit souvent le manuel plutôt que le vrai système. C'est la leçon d'un billet publié en mai 2026 sur le blog de l'ACM SIGOPS par l'équipe Specula, qui présente le benchmark SysMoBench (ICLR 2026).

L'anecdote de départ est parlante. L'équipe demande à Claude une spécification TLA+ de l'implémentation Raft d'etcd. Le résultat compile et tourne dans le model checker TLC. Mais il ressemble surtout à la spec de référence en annexe du papier Raft, avec très peu de détails propres à etcd. Le modèle a récité le cours au lieu de lire le code.

SysMoBench formalise ce test sur onze systèmes, des verrous d'Asterinas jusqu'à etcd Raft, ZooKeeper, RedisRaft et CURP. Chaque spec générée passe quatre étapes :

  1. Syntaxe : la spec compile-t-elle ?
  2. Exécution : TLC peut-il la faire tourner sans erreur ?
  3. Conformité : les traces du vrai code correspondent-elles au modèle ?
  4. Invariants : la spec respecte-t-elle les propriétés de sûreté et de vivacité ?

Les résultats suivent une pente très nette. La syntaxe est proche de 100 % pour la plupart des modèles de pointe. La conformité tombe à environ 46 % en moyenne et les invariants à environ 41 %. Sur les systèmes distribués complexes, les specs qui tournent se situent entre 10 % et 50 %. Claude Sonnet 4.6 n'obtient que 25 % au total sur RedisRaft et CURP.

Les erreurs observées sont celles qu'un développeur expérimenté reconnaîtra tout de suite. Dans une spec de l'élection de leader de ZooKeeper, le modèle garde l'ancien et le nouveau vote d'un même pair dans un ensemble. Le vrai code les range par expéditeur : le nouveau vote remplace l'ancien. La spec atteint donc des états que le système ne produit jamais. Dans la même spec, deux étapes du code sont fusionnées en une seule opération atomique, ce qui fait disparaître des états qui arrivent à chaque élection.

Ces specs compilent et tournent. Seuls les tests de conformité et d'invariants révèlent qu'elles suivent un modèle de manuel, pas l'implémentation réelle.

Ce que ça change pour un développeur maintenant

Si l'IA prend en charge le code facile, la valeur d'un développeur se déplace vers ce qu'elle maîtrise mal. Les deux études pointent dans la même direction.

  • Concevoir avant de générer. Choisir entre cohérence et disponibilité, synchrone et asynchrone, at-least-once et exactly-once. Ces décisions déterminent la suite et l'IA les prend rarement bien toute seule.
  • Relire le code généré avec un œil « distribué ». Un retry sans idempotence, un timeout sans gestion de la reprise, deux opérations supposées atomiques qui ne le sont pas. Le code compile, les tests unitaires passent et le bug arrive en production.
  • Donner du contexte d'exécution à vos agents. DDBench le montre clairement : des logs, des traces et l'état des nœuds font gagner presque 20 points de réussite. Une bonne observabilité sert maintenant aussi à vos outils d'IA, pas seulement à votre équipe d'astreinte.
  • Vérifier ce qui ne se voit pas. SysMoBench le rappelle : une spec qui compile n'est pas une spec juste. Il en va de même pour le code. Les tests qui comptent sont ceux qui confrontent le modèle au comportement réel.

Un dernier point me paraît important. Les systèmes multi-agents remettent ces sujets au premier plan. Dès que deux agents partagent une mémoire, un index ou un outil, vous avez construit un système distribué. Les race conditions et les problèmes d'ordre des événements arrivent avec, même si l'une des briques est un LLM.

En résumé

On parle moins de systèmes distribués parce que le discours sur l'IA porte sur la vitesse, pas parce que le problème est réglé. Sur les vrais bugs distribués, les meilleurs modèles réussissent environ une fois sur deux. Sur la modélisation de systèmes réels, ils récitent souvent le manuel.

Pour un développeur, c'est une bonne nouvelle. Maîtriser les systèmes distribués tout en utilisant l'IA, c'est un profil rare et qui prend de la valeur. L'IA écrit le code; c'est à vous de comprendre comment il se comporte quand le réseau tombe.

Références