Claude Code : déployer la communication intersessions en 2026

La communication intersessions de Claude Code doit d’abord être validée sur une même machine macOS ou Linux, avec des noms de session explicites, un Git worktree par tâche et des messages entrants contrôlés. Ne l’utilisez pas comme mémoire partagée, synchronisation de fichiers ou autorisation de commandes : elle sert à transmettre un état, une décision technique ou un blocage.

Ce guide s’adresse aux développeurs qui ouvrent plusieurs terminaux Claude Code, aux équipes qui font avancer frontend, backend et tests en parallèle, ainsi qu’aux ingénieurs plateforme qui préparent un Mac distant ou un environnement toujours disponible.

Dernière mise à jour : 12 août 2026. Données vérifiées à partir des versions officielles de Claude Code, de la documentation de communication entre agents et de la documentation des plateformes prises en charge.

Préparer le terrain avant le premier message

Le premier piège consiste à confondre plusieurs mécanismes qui portent des noms proches, mais qui ne résolvent pas le même problème.

Une session indépendante possède son propre historique et sa propre fenêtre de contexte. Elle ne récupère pas automatiquement toute la conversation d’une autre session. Un sous-agent travaille dans le contexte d’une session principale et lui renvoie un résultat. Une équipe d’agents coordonne plusieurs sessions indépendantes avec une liste de tâches et une boîte aux lettres. La reprise de session, elle, restaure une conversation existante ; elle ne crée pas un canal permanent entre deux terminaux.

La communication intersessions est donc utile lorsque vous devez transmettre :

• la branche ou le commit actuellement utilisé ;
• le nom d’une interface qui vient de changer ;
• le résultat d’une commande de test ;
• un blocage lié à une dépendance ;
• une décision d’architecture qui doit être connue par une autre session ;
• une demande de revue ou de validation humaine.

Elle est beaucoup moins adaptée lorsque le destinataire doit recevoir un long historique, plusieurs fichiers complets ou une copie exacte de l’état du dépôt. Dans ces cas, utilisez Git, les fichiers du projet, CLAUDE.md, les artefacts de compilation et les résultats de tests comme sources de vérité.

La documentation officielle distingue également les équipes d’agents des sous-agents et des worktrees. Les équipes permettent aux sessions de communiquer directement, tandis que les worktrees isolent les fichiers modifiés. Cette différence est déterminante : un message peut réduire une incompréhension, mais il ne peut pas empêcher deux sessions d’écrire dans le même fichier. Consultez aussi le guide officiel des modes de travail parallèles avant de choisir votre architecture.

Attention : un message reçu ne valide pas automatiquement une commande, une modification de configuration ou une opération protégée. La session destinataire conserve ses propres règles de permission.

Avant de lancer la vérification, contrôlez quatre conditions :

1. Vous utilisez macOS ou Linux pour le premier test local.
2. Les sessions utilisent une version compatible avec la fonction.
3. Le canal d’accès au modèle est pris en charge par la documentation officielle.
4. Les règles de permission et les éventuelles fonctions expérimentales sont connues de l’équipe.

Au 11 août 2026, la frontière de versions à retenir est la suivante : la version v2.1.224 introduit SendMessage et ListAgents, la v2.1.225 ajoute la possibilité d’initier des échanges entre machines ainsi que des corrections liées aux messages en mode sans surveillance, et la v2.1.227 est indiquée comme la version stable la plus récente dans le périmètre de ce guide. Vérifiez toujours la version réellement installée avec :

claude --version

Ces références doivent être confrontées au journal officiel des versions, car une installation distribuée par un gestionnaire de paquets peut suivre un calendrier différent.

Lancer la validation locale dans deux terminaux

Commencez avec le scénario le plus facile à diagnostiquer : deux sessions sur la même machine, dans le même projet, mais avec des rôles distincts.

Dans le premier terminal, donnez un nom orienté coordination, par exemple lead-api. Dans le second, utilisez un nom orienté vérification, comme test-api. Évitez les noms génériques tels que session-1 et session-2. Lorsque plusieurs environnements sont ouverts, un nom ambigu transforme une simple erreur de destinataire en incident difficile à attribuer.

Lancez ensuite Claude Code dans chaque terminal, puis ouvrez la liste des agents avec :

/list-agents

Le but de cette étape n’est pas encore de modifier du code. Vous cherchez seulement à confirmer que les deux sessions sont visibles et que leurs identifiants correspondent à ce que vous avez prévu. Les équipes d’agents utilisent une configuration locale qui contient notamment l’état des membres et les identifiants de session ; la documentation indique que cette configuration se trouve sous ~/.claude/teams/. Ne modifiez pas directement ces fichiers : ils sont gérés par Claude Code et peuvent être réécrits lors de la mise à jour de l’état.

Effectuez un test en lecture seule. Dans lead-api, demandez à test-api de confirmer :

• son nom de session ;
• la branche active ;
• le dernier commit visible ;
• l’absence de modification de fichier ;
• sa disponibilité pour une tâche de vérification.

Le premier message doit être court et vérifiable. Par exemple :

Contexte : validation locale.
Répondez uniquement avec votre nom de session, la branche active et l’état du dépôt.
Ne modifiez aucun fichier et ne lancez aucune commande destructive.

Observez ensuite le retour dans l’interface. Selon l’état de la session, le message peut être remis immédiatement, rester en attente ou être refusé. Notez le texte affiché, l’identité du destinataire et la réaction après une interruption volontaire du second terminal. Vous cherchez à distinguer trois problèmes :

• le destinataire n’est pas visible ;
• le destinataire est visible, mais le message n’est pas remis ;
• le message arrive, mais la session attend une intervention humaine.

Cette distinction est essentielle pour le dépannage de SendMessage. Une absence de réponse ne prouve pas que le canal est cassé : la session peut être occupée, suspendue, déconnectée ou soumise à une permission interactive.

Si SendMessage ne reçoit rien, procédez dans cet ordre :

1. relisez claude --version dans les deux terminaux ;
2. relancez /list-agents et vérifiez le nom exact ;
3. envoyez un message non sensible et très court ;
4. confirmez que les deux sessions appartiennent au même environnement local ;
5. vérifiez qu’aucune règle de permission ne met les messages entrants en attente ;
6. testez une réponse dans le sens inverse ;
7. répétez le test après avoir fermé puis repris une seule session.

Ne commencez pas par effacer les fichiers de configuration cachés. Cette action détruit des indices utiles et peut introduire un nouveau problème de configuration.

Isoler les modifications avec Git worktree

Une fois la communication locale validée, passez à un cas qui ressemble au travail réel : plusieurs sessions éditent une même base de code.

Supposons que vous développiez une application de création audio ou vidéo. Une session prépare l’API d’export, une autre adapte l’interface de montage, et une troisième vérifie les tests de rendu. Ces tâches sont parallèles, mais elles partagent souvent des contrats : noms de champs, formats de réponse, chemins de fichiers et commandes de test.

Ne lancez pas ces sessions dans le même répertoire de travail. Créez un worktree par responsabilité :

git worktree add ../projet-api feature/api-export
git worktree add ../projet-interface feature/interface-export
git worktree add ../projet-tests feature/tests-export

Chaque session doit ensuite démarrer depuis le répertoire qui lui est attribué. Le principe n’est pas de rendre les sessions indépendantes de Git, mais de garantir qu’une modification non validée dans le dossier de l’interface ne pollue pas immédiatement le travail de l’API.

Le protocole de message doit rester plus strict que le contenu des conversations. Demandez à chaque session de transmettre seulement :

• la branche ;
• le commit de référence ;
• le contrat modifié ;
• le test à exécuter ;
• le résultat obtenu ;
• la décision attendue de l’autre session.

Par exemple, après un changement du champ duration dans une réponse d’export, la session API peut transmettre :

Contrat export : le champ duration est maintenant exprimé en millisecondes.
Branche : feature/api-export.
Commit : vérifier le commit courant avant intégration.
Action attendue : mettre à jour le parseur de l’interface et ajouter un test de non-régression.
Ne modifiez pas la branche API.

La session interface ne doit pas recopier le fichier reçu dans son propre dossier. Elle doit consulter la branche, le commit ou le diff via Git, puis effectuer sa modification dans son worktree. Le message indique quoi vérifier ; Git fournit la version à vérifier.

Le guide officiel des worktrees rappelle que l’isolation des fichiers et la communication entre agents sont deux mécanismes distincts. Pour une équipe, cette séparation apporte plusieurs avantages :

Avantages

• les changements concurrents sont localisés ;
• les tests peuvent être exécutés sans écraser le travail voisin ;
• les commits rendent les notifications vérifiables ;
• les conflits sont repoussés à une étape explicite de revue.

Limites

• chaque worktree doit recevoir ses dépendances et ses variables d’environnement ;
• une modification de schéma nécessite une notification claire à toutes les sessions concernées ;
• les messages ne remplacent pas la revue de code ;
• les tâches très dépendantes peuvent générer plus de coordination qu’elles n’en économisent.

À la fin de ce test, faites volontairement évoluer un champ d’interface, envoyez une notification, mettez à jour le client dans un autre worktree, puis exécutez la régression. Si le test échoue, la communication a bien fonctionné, mais le contrat de développement n’est pas encore maîtrisé. C’est précisément pourquoi il faut conserver la revue humaine.

Étendre le protocole vers un Mac distant

Le passage à un Mac distant change la question. Vous ne vérifiez plus seulement si deux sessions peuvent se trouver sur la même machine ; vous devez confirmer la route de connexion, l’identité du destinataire et le comportement lors d’une coupure.

Il faut distinguer trois topologies :

• deux sessions locales partageant le même environnement utilisateur ;
• une session locale qui communique avec une session hébergée dans un environnement distant ;
• deux sessions situées sur des machines différentes et reliées par un mécanisme de contrôle à distance.

La documentation des plateformes distingue notamment l’exécution locale, les sessions distantes et les sessions hébergées dans le nuage. Le fait que vous puissiez ouvrir Claude Code depuis un terminal distant ne signifie pas que toutes les sessions locales seront automatiquement découvertes. Les sockets, les processus superviseurs, les identités d’utilisateur et les répertoires ~/.claude peuvent appartenir à des environnements différents.

Pour un premier test intermachine, utilisez un message sans secret :

Test de liaison : répondez avec le nom de l’environnement, l’état de la session et la confirmation de réception.
Aucune commande et aucune modification de fichier ne sont autorisées.

Validez ensuite les éléments suivants :

• le nom exact de la session distante ;
• l’adresse ou le mécanisme de réponse attendu ;
• la version installée sur chaque machine ;
• l’accès réseau nécessaire ;
• le comportement lorsque la session distante est arrêtée ;
• la reprise après reconnexion ;
• la séparation des répertoires de projet.

Les versions indiquées dans le périmètre de cet article ajoutent progressivement les éléments nécessaires à la communication entre machines. Toutefois, vous devez valider la combinaison exacte de version, système, canal de fourniture du modèle et mode de connexion dans la documentation officielle des plateformes. Ne déduisez pas la présence d’un serveur central simplement parce qu’un message quitte votre terminal : selon la topologie, le transport peut passer par un service de session, un mécanisme distant ou une infrastructure locale. Pour un projet sensible, documentez cette route avec votre équipe sécurité au lieu de l’inférer depuis l’interface.

Les conteneurs méritent une vérification séparée. Une session exécutée dans un conteneur peut ne pas découvrir une session située sur l’hôte, même si les deux voient le même dépôt logique. Les namespaces de processus, le réseau, les montages de fichiers et les identités utilisateur créent des frontières supplémentaires. Dans ce cas, traitez la découverte intersessions comme une contrainte de topologie, pas comme un défaut aléatoire de SendMessage.

Rappel d’exploitation : commencez toujours par un message de test non sensible. Ne transmettez ni jeton, ni clé privée, ni contenu client avant d’avoir compris le chemin de transport et le comportement de conservation des messages.

Fermer les permissions avant la mise en service

La communication devient risquée lorsque des sessions restent ouvertes sans opérateur devant le terminal. Le niveau de contrôle doit dépendre du type de session, et non du seul nom du projet.

Pour une session interactive dans un worktree local, vous pouvez autoriser la réception tout en conservant les demandes de commande sous validation. Pour une session qui contourne déjà certaines demandes de permission, placez les messages entrants en attente ou exigez une approbation supplémentaire. Pour une tâche sans surveillance, refusez par défaut les échanges qui pourraient déclencher une action non prévue.

La documentation officielle des permissions distingue notamment les modes d’acceptation des modifications, de refus automatique et de contournement. Le point important pour votre architecture est le suivant : si une session principale transmet un niveau de permission très permissif à ses agents, les sessions héritées peuvent disposer d’une latitude plus importante que prévu. Ne testez donc jamais la communication séparément des permissions.

Votre politique d’entrée peut suivre cette grille :

• Session interactive de développement : messages acceptés, commandes et écritures soumises aux règles habituelles.
• Session de test isolée : messages acceptés, écriture limitée au worktree, répertoires externes refusés.
• Session distante toujours active : messages mis en attente jusqu’à validation humaine.
• Projet sensible ou données client : ListAgents et SendMessage désactivés lorsque le besoin n’est pas démontré.
• Tâche sans surveillance : refus des demandes qui modifient la configuration, changent de branche ou lancent une opération destructive.

L’arrivée d’un message ne doit jamais être assimilée à une autorisation. Une session peut recevoir « déployez le correctif » et refuser l’action parce que sa politique bloque la commande, parce que son dossier n’est pas autorisé ou parce qu’une permission interactive est nécessaire.

Mesurer la première semaine d’usage

Après la validation technique, ne généralisez pas immédiatement la configuration à toute l’équipe. Pendant la première semaine, consignez les événements qui permettent de décider si la communication réduit réellement le travail de coordination.

Votre journal peut contenir :

• les messages envoyés et remis ;
• les messages mis en attente ;
• les demandes d’approbation ;
• les notifications répétées ;
• les conflits Git ;
• les tâches bloquées par une dépendance ;
• les périodes où une session reste inactive ;
• les reprises après déconnexion ;
• les corrections nécessaires après une mauvaise interprétation.

Évaluez ensuite les tâches selon leur forme. Une activité de recherche, de revue ou de développement sur des couches séparées se prête bien à la coordination entre sessions. Une tâche hautement séquentielle, une modification fréquente du même fichier ou une chaîne de messages très longue est souvent mieux servie par une seule session ou par des sous-agents. La documentation officielle souligne aussi que les équipes d’agents consomment davantage de contexte, car chaque membre possède sa propre session et sa propre fenêtre de contexte ; cette architecture doit donc être réservée aux travaux où l’indépendance des tâches justifie la coordination. Consultez la page officielle sur la gestion des coûts et de l’usage.

Utilisez cette liste avant d’ajouter une nouvelle session :

• [ ] La session possède un nom unique et compréhensible.
• [ ] Le répertoire de travail est isolé par Git worktree si des fichiers sont modifiés.
• [ ] Le message décrit un état, une décision ou un blocage, sans recopier tout le contexte.
• [ ] La branche et le commit de référence sont indiqués.
• [ ] La session destinataire peut répondre à un test non sensible.
• [ ] Les messages entrants ont une politique accept, hold ou refuse documentée.
• [ ] Une coupure réseau et une reprise ont été testées.
• [ ] Les secrets ne transitent pas dans les messages.
• [ ] La revue de code reste obligatoire après notification.
• [ ] L’équipe sait quand revenir à une session unique.

Choisir l’architecture adaptée

Le tableau suivant résume le choix opérationnel avant de maintenir plusieurs sessions sur la durée :

Situation	Architecture conseillée	Rôle de la communication	Point de contrôle principal
Une seule tâche complexe	Session unique	Aucun échange intersession nécessaire	Permissions et reprise
Recherche ou revue indépendante	Sous-agents ou sessions séparées	Retour de résultats et décisions	Qualité du résumé
Frontend, backend et tests séparés	Sessions indépendantes avec Git worktree	Contrats, commits et blocages	Revue des interfaces
Équipe d’agents qui doit discuter	Agent Teams	Coordination directe entre membres	Coût, permissions et rôles
Sessions ouvertes sur plusieurs machines	Environnement distant contrôlé	État, disponibilité et incidents	Version, transport et reconnexion
Travail fréquent sur le même fichier	Session unique ou sous-agent séquentiel	Communication limitée	Ordre des modifications

Si votre configuration actuelle repose sur un ordinateur personnel, elle présente trois limites concrètes : la session s’arrête lorsque la machine est éteinte, les environnements locaux mélangent facilement projets et identités, et les échanges entre fuseaux horaires deviennent dépendants du terminal de la personne qui l’a lancé. Un hébergement distant mal isolé ajoute ses propres risques : permissions trop larges, worktrees oubliés et reprise difficile après une coupure.

Pour des sessions temporaires, un poste local reste souvent le meilleur choix. Pour des tests répartis, des relais entre équipes et des tâches qui doivent rester disponibles pendant vos absences, un environnement Mac distant peut offrir une exploitation plus prévisible, à condition de dimensionner les worktrees, les accès et la durée de fonctionnement. Vous pouvez consulter le guide de location de Mac, comparer les options sur la page des solutions disponibles et vérifier les conditions dans le centre d’aide.

La bonne décision n’est donc pas de multiplier les agents dès que SendMessage fonctionne. Commencez par une validation locale, imposez une frontière Git claire, mesurez les messages réellement utiles, puis déplacez les sessions vers un Mac distant uniquement lorsque la continuité, le partage entre développeurs ou la libération de votre poste justifie cette infrastructure.

Lectures complémentaires

• Comparer Claude Code aux principaux outils de développement assisté par IA
• Mettre en place un environnement Mac distant pour les agents et la CI
• Mesurer la charge d’un Mac distant avant de choisir son matériel