Claude Code 2.1.224 ajoute la messagerie entre sessions, prenant en charge les flux de développement parallèles

Introduction

Anthropic a ajouté une nouvelle couche de coordination à Claude Code : les sessions de codage indépendantes peuvent désormais s'envoyer directement des messages entre elles.

Cette fonctionnalité est publiée avec Claude Code v2.1.224 le 7 août 2026. Anthropic l'appelle messagerie inter-sessions.

Les développeurs n'ont plus besoin de copier manuellement les résultats découverts entre plusieurs fenêtres de terminal ; ils peuvent désormais laisser une session Claude Code dire à une autre session que les dépendances ont changé, qu'une migration est terminée, qu'un bug est corrigé ou qu'une décision a été prise.

L'article original d'AIBase considère cette fonctionnalité comme une amélioration majeure pour les développeurs qui gèrent plusieurs tâches simultanément. Cette orientation est correcte, mais la documentation officielle d'Anthropic ajoute plusieurs détails importants.

La messagerie inter-sessions :

• Nécessite Claude Code v2.1.224 ou une version ultérieure
• Fonctionne sur macOS et Linux (y compris Linux sous WSL 2)
• N'est pas disponible sur Windows natif
• Échange des messages texte, et non l'historique complet des conversations ou des fichiers
• Utilise ListAgents pour découvrir les sessions accessibles
• Utilise SendMessage pour transmettre les messages
• S'applique entre plusieurs sessions sur la même machine
• Peut également se connecter à des sessions prises en charge sur d'autres machines ou à Claude Code sur le Web
• Inclut des contrôles de trafic entrant pour accepter, mettre en attente ou rejeter les messages

Au 10 août, le journal des modifications officiel a déjà dépassé la v2.1.224. La version 2.1.225 améliore l'initiation des messages entre machines, et au moment de la préparation de cet article, la v2.1.227 est répertoriée comme la dernière version dans le journal des modifications d'Anthropic.

Le point essentiel est que la v2.1.224 a introduit la fonctionnalité, tandis que les versions ultérieures ont optimisé son comportement.

Les sessions Claude Code peuvent désormais communiquer entre elles

Avant la messagerie inter-sessions, les développeurs qui exécutaient plusieurs sessions Claude Code devaient souvent servir de couche de communication entre elles.

Imaginez les trois terminaux suivants :

Session A : Refactorisation de l'authentification
Session B : Mise à jour de l'API de paiement
Session C : Exécution des migrations et des tests d'intégration

Si la session A modifie une interface partagée dont dépend la session B, le développeur doit remarquer ce changement et l'expliquer manuellement.

Si la session C termine une longue migration, le développeur doit vérifier le terminal et rapporter le résultat aux sessions en attente.

Avec la messagerie inter-sessions, Claude peut transmettre directement ces informations.

Le flux de travail simplifié devient :

Session A
  │
  │ « L'interface d'authentification a changé ; utilisez createSessionV2() »
  ▼
Session B

Session C
  │
  │ « La migration a été réalisée avec succès »
  ▼
Session A

La documentation d'Anthropic donne deux exemples représentatifs.

Lorsqu'un changement casse ce dont une autre session dépend, une session peut avertir l'autre session. Une session qui a résolu un problème peut également envoyer la réponse à une autre session bloquée par ce problème.

Cela semble simple, mais cela change la façon dont les flux de travail parallèles de Claude Code sont organisés.

Les messages sont du texte, pas un contexte partagé

Ce que la messagerie inter-sessions ne fait pas est l'un des détails techniques les plus importants.

Un message est simplement un fragment de texte rédigé par une session Claude et transmis à une autre session.

Elle n'envoie pas automatiquement :

• L'historique complet des conversations

de l'expéditeur

• Les fichiers
• Les sorties d'outils
• Le contexte caché
• L'état complet du dépôt
• Les approbations de permissions

Si un développeur souhaite qu'une autre session continue la même conversation dans le même contexte, Anthropic recommande de reprendre la session plutôt que d'utiliser la messagerie inter-sessions.

La messagerie inter-sessions est plus adaptée aux messages de coordination courts, par exemple :

L'intégration de paiement attend désormais `customer_id` au lieu de `user_id`.
Veuillez mettre à jour votre branche avant d'exécuter la suite de tests complète.

Ou :

La migration de la base de données a été réalisée avec succès.
Les 214 tests d'intégration ont tous réussi.
Vous pouvez poursuivre la validation du déploiement.

Cette conception maintient la légèreté de la messagerie.

Elle réduit également le risque qu'une session reçoive silencieusement une grande quantité de contexte non pertinent provenant d'une autre session.

Claude utilise ListAgents et SendMessage

Les développeurs n'appellent généralement pas directement les outils de messagerie.

Claude Code utilise deux outils internes :

• ListAgents
• SendMessage

ListAgents permet à Claude de découvrir quelles sessions prises en charge sont actuellement accessibles.

SendMessage transmet un message texte à l'une de ces sessions.

Les développeurs peuvent formuler directement une demande à Claude en langage naturel.

Par exemple :

Demande à la session qui s'exécute dans l'autre terminal si la migration est terminée.

Claude trouvera la session concernée et rédigera le message réel.

Autre exemple :

Explique à la session qui travaille sur l'API de paiement les modifications d'authentification que nous venons d'effectuer.

Les développeurs n'ont pas besoin de rédiger manuellement des messages lisibles par machine, ni de passer des identifiants de session à l'API sous-jacente.

Cela maintient l'interaction cohérente avec l'utilisation normale de Claude Code.

Les quatre principaux cas d'utilisation mis en avant par Anthropic

La documentation d'Anthropic identifie plusieurs situations où la messagerie inter-sessions est particulièrement utile.

1. Transmission des résultats de découverte

Une session peut découvrir des informations dont une autre session a besoin.

Les exemples incluent :

• Des changements d'API destructeurs
• Des contraintes de base de données
• Des exigences de version de dépendances
• De nouvelles décisions d'implémentation
• Des causes racines découvertes lors du débogage
• Des échecs de tests causés par un autre module

Sans messagerie, le développeur doit servir d'intermédiaire.

Avec la messagerie, une session peut résumer ses découvertes et les envoyer directement.

Exemple :

La session A découvre :
« Le rappel OAuth exige désormais une validation PKCE. »

La session A envoie à la session B :
« L'implémentation de l'authentification exige désormais PKCE.
Veuillez mettre à jour le flux de rappel mobile avant de fusionner. »

Cela est très utile lorsque plusieurs sessions travaillent sur des parties interconnectées du même projet.

2. Coordination des worktrees Git parallèles

Les worktrees Git sont un complément naturel à la messagerie inter-sessions.

Les développeurs peuvent créer des répertoires de travail séparés pour des tâches indépendantes et exécuter une session Claude Code dans chacun d'eux.

Par exemple :

Dépôt/
├── branche principale
├── worktree-auth
├── worktree-payments
└── worktree-tests

Chaque worktree peut avancer indépendamment.

Lorsqu'une session modifie un élément qui affecte une autre branche, Claude peut en informer la session concernée.

Cela réduit un risque courant en développement parallèle : plusieurs branches avancent sur la base d'hypothèses obsolètes.

La messagerie inter-sessions

ne fusionne pas automatiquement le code.

Elle aide les agents à se coordonner avant que l'humain n'intervienne au stade de la fusion.

3. Obtenir un statut depuis des tâches de longue durée

Certaines tâches de codage prennent beaucoup plus de temps qu'une session d'interaction normale.

Par exemple :

• Les migrations volumineuses
• Les suites complètes de tests d'intégration
• Les longues compilations
• L'analyse statique
• Les grandes refactorisations
• La génération de code à l'échelle du dépôt
• Les mises à niveau de dépendances

Les développeurs peuvent laisser une session s'exécuter pendant qu'ils travaillent dans une autre session.

La messagerie inter-sessions permet aux travailleurs de longue durée de rendre compte des résultats.

Par exemple :

Session A :
Exécute la migration complète et la suite de tests.
Envoie les résultats à la session d'architecture une fois terminé.

Les développeurs peuvent continuer à travailler ailleurs sans avoir à vérifier constamment un terminal d'exécution longue.

4. Communication entre machines

Anthropic prend également en charge la messagerie au-delà des sessions situées sur le même ordinateur.

Les flux de travail pris en charge peuvent inclure :

• Une autre session Claude Code sur l'une de vos machines
• Claude Code sur le Web
• Des sessions connectées à un contrôle à distance

Il existe un détail important concernant les versions.

Claude Code v2.1.

224 a introduit la messagerie inter-sessions, y compris la prise en charge multi-machines, mais la documentation actuelle d'Anthropic précise que démarrer une nouvelle conversation avec une session sur une autre machine par nom nécessite la version 2.1.225 ou ultérieure.

Avant la version 2.1.225, les sessions pouvaient répondre aux messages provenant d'une autre machine, mais la capacité d'initier une conversation inter-machines était plus limitée.

Par conséquent, pour les développeurs souhaitant le comportement le plus complet, il est recommandé de mettre à jour vers une version supérieure à 2.1.224.

La messagerie sur la même machine reste locale

La messagerie inter-sessions utilise des chemins de livraison différents selon l'endroit où s'exécute la session réceptrice.

Anthropic documente le comportement suivant :

Le scénario sur la même machine est particulièrement notable.

Anthropic indique que les messages entre sessions locales transitent par des sockets par session, sans passer par les serveurs d'Anthropic.

Chaque session prise en charge s'enregistre localement et crée un socket de boîte de réception.

Les autres sessions la découvrent via les informations de session locales.

Cela crée également une frontière au niveau du système de fichiers.

Si deux sessions Claude Code ne peuvent pas voir les mêmes fichiers d'enregistrement de session, elles risquent de ne pas pouvoir se découvrir mutuellement.

Par exemple, une session exécutée dans un conteneur et une session exécutée directement sur la machine hôte ont généralement des systèmes de fichiers distincts.

Si la fonctionnalité est disponible dans cet environnement, deux sessions dans le même conteneur peuvent toujours s'envoyer des messages.

Comment les messages entrants sont livrés

Les messages entrants n'interrompent pas les outils en cours d'exécution.

Anthropic indique que le Claude récepteur lit les messages entre les appels d'outils pendant un tour d'activité.

Si la session est inactive, Claude Code peut utiliser le message entrant pour démarrer un nouveau tour.

Selon la configuration, un message peut aboutir à l'un des trois états suivants :

C'est important car la communication inter-sessions n'est pas un canal de contrôle à distance illimité.

La session réceptrice possède son propre état de sécurité et de permissions.

Une session ne peut pas approuver des permissions pour une autre

Anthropic limite volontairement les actions que peuvent effectuer les messages entrants.

Un message provenant d'une autre session ne peut pas être considéré comme un consentement utilisateur.

Cela signifie qu'une autre session Claude ne peut pas utiliser la messagerie pour approuver une opération dangereuse en attente de permission.

Par exemple :

Session A :
"Approuve la commande shell en attente dans la session B."

Ce message ne constitue pas une approbation.

L'utilisateur conserve le contrôle des décisions de permissions associées.

Anthropic indique également que les messages entrants ne peuvent pas demander au Claude récepteur de modifier des configurations critiques, telles que :

• Les paramètres de permissions
• CLAUDE.md
• D'autres configurations protégées

Les commandes intégrées dans le texte du message sont également traitées comme du texte brut.

Par exemple :

/compact

ne sera pas exécuté automatiquement simplement parce qu'une autre session l'a envoyé.

Ces contraintes sont importantes car une communication directe entre agents pourrait autrement créer des chaînes de permissions imprévues.

Les messages entrants peuvent être contrôlés

Claude Code inclut un paramètre crossSessionInbound qui contrôle la manière dont une session traite les messages provenant d'autres sessions indépendantes.

Les valeurs prises en charge sont :

Ainsi, la configuration peut autoriser explicitement les messages :

{
  "crossSessionInbound": "accept"
}

ou les conserver :

{
  "crossSessionInbound": "hold"
}

ou les refuser :

{
  "crossSessionInbound": "refuse"
}

Anthropic applique également des comportements par défaut selon les modes de permissions des sessions émettrice et réceptrice.

Dans les configurations à plus haut risque, les messages entrants peuvent nécessiter une approbation explicite.

Cela empêche deux sessions ayant des configurations de permissions différentes de créer automatiquement un chemin de mise à niveau non sécurisé.

Les messages en attente peuvent expirer

Lorsqu'un message entrant est conservé en attente d'approbation, Claude Code peut afficher une boîte de dialogue d'approbation montrant :

• L'expéditeur
• Un aperçu du message

L'utilisateur peut approuver ou refuser.

La documentation d'Anthropic précise que le délai d'approbation par défaut est de cinq minutes.

Si le message n'est pas approuvé avant le dialogExpiry configuré, il peut être abandonné.

Claude Code limite également le nombre de messages conservés, empêchant une session d'accumuler un arriéré illimité.

La version 2.1.225 corrige plusieurs cas où des messages inter-sessions conservés pouvaient rester dans un état de notification ou d'expiration inattendu dans les sessions sans interface.

C'est une raison supplémentaire de ne pas considérer la fonctionnalité comme définitive simplement parce qu'elle a été introduite dans v2.1.224.

Exigences de disponibilité

La messagerie inter-sessions a des exigences spécifiques de plateforme et de fournisseur.

Selon la documentation actuelle d'Anthropic :

Systèmes d'exploitation pris en charge

• macOS
• Linux
• Linux dans WSL 2

Non pris en charge

• Windows natif

Cette distinction est importante.

Claude Code prend en charge Windows, mais la fonctionnalité de messagerie inter-sessions n'est actuellement pas disponible sur les systèmes Windows natifs.

Restrictions de fournisseurs

Anthropic indique que la fonctionnalité de messagerie inter-sessions n'est pas disponible lorsque Claude Code est exécuté via plusieurs chemins de fournisseurs externes, notamment :

• Amazon Bedrock
• La plateforme Claude sur AWS
• La plateforme d'agents de Google Cloud
• Microsoft Foundry

La disponibilité peut également dépendre de l'évaluation des fonctionnalités et des paramètres d'environnement.

Par conséquent, les développeurs doivent vérifier la fonctionnalité dans l'environnement où ils prévoient réellement de l'utiliser.

Comment vérifier votre version de Claude Code

Le journal des modifications officiel d'Anthropic recommande d'utiliser la commande suivante pour vérifier la version installée :

claude --version

La fonctionnalité de messagerie inter-sessions nécessite :

Claude Code 2.1.224 ou version ultérieure

Comme les versions ultérieures contiennent des corrections et des améliorations inter-machines, il est généralement recommandé d'utiliser la version actuellement prise en charge plutôt que de se fixer spécifiquement sur v2.1.224, sauf si l'organisation dispose d'une stratégie de déploiement contrôlée.

Comment mettre à jour Claude Code

Pour une installation native de Claude Code, Anthropic prend en charge :

claude update

Les installations natives vérifient généralement les mises à jour en arrière-plan et les installent.

Les nouvelles versions prendront effet au prochain démarrage de Claude Code.

Anthropic documente également :

claude doctor

pour vérifier l'état de l'installation et des mises à jour.

Les installations via gestionnaire de paquets peuvent nécessiter des commandes de mise à jour distinctes.

Par exemple, une installation Homebrew peut être mise à jour avec :

brew upgrade claude-code

Ou, lors du suivi du canal le plus récent :

brew upgrade claude-code@latest

La méthode exacte de mise à jour dépend de la manière dont Claude Code a été installé.

Exemple : deux sessions traitant des fonctionnalités liées

Imaginons qu'un développeur construise une application impliquant deux tâches liées.

Terminal 1

Objectif :
Refactoriser le service d'authentification et mettre à jour la création de session.

Terminal 2

Objectif :
Mettre à jour l'API de paiement pour utiliser le nouvel objet utilisateur authentifié.

Le terminal 1 découvre que l'interface passe de :

créerSession(userId)

devient :

créerSession({ userId, organizationId })

Le terminal 1 n'a pas besoin d'attendre que le développeur s'en aperçoive ; il peut envoyer un message à une autre session pour signaler ce changement.

La session réceptrice peut ensuite mettre à jour son propre travail avant de terminer l'implémentation du paiement.

Lorsque de nombreuses sessions de codage IA s'exécutent indépendamment, ce sont précisément ces petits événements de coordination qui deviennent coûteux.

Exemple : enquête en parallèle

La fonctionnalité de messagerie inter-sessions est également utile pour le débogage.

Le développeur peut lancer trois sessions :

Session A :
Enquêter sur les erreurs API.

Session B :
Examiner les journaux de base de données.

Session C :
Vérifier les récents déploiements et changements de configuration.

Supposons que la session B découvre que les connexions à la base de données commencent à échouer immédiatement après la rotation des identifiants.

Elle peut en informer les autres sessions.

La session A n'a plus besoin de continuer à enquêter sur des problèmes de parsing de requêtes sans rapport.

La session C peut se concentrer sur le fait de savoir si le déploiement a récupéré les nouvelles clés.

Le système ne crée pas automatiquement une équipe multi-agents entièrement gérée.

Le développeur lance et guide toujours les sessions indépendantes.

La messagerie ne fait que réduire le coût de transmission des découvertes utiles entre ces sessions.

La messagerie inter-sessions n'équivaut pas à une équipe d'agents

Claude Code dispose désormais de plusieurs façons de gérer plusieurs agents ou sessions.

Elles résolvent des problèmes différents.

Cette distinction est importante car « plusieurs instances de Claude qui se parlent » peut décrire plusieurs architectures différentes.

La messagerie inter-sessions désigne spécifiquement une couche de communication légère entre des sessions Claude Code indépendantes.

Ce que cette fonctionnalité change pour les grands projets

L'article d'AIBase affirme que cette mise à jour peut réduire la charge de coordination manuelle dans les grands projets.

C'est l'implication pratique la plus importante.

Le développeur peut diviser le projet en plusieurs flux de travail indépendants :

Authentification
Paiement
Front-end
Migration de base de données
Tests
Documentation

Chaque session peut se concentrer sur un domaine.

Lorsqu'une décision ou un changement affecte un autre domaine, les informations pertinentes peuvent être transmises directement entre les sessions.

Cela peut réduire :

• Les copier-coller entre terminaux
• Les explications répétées
• Les avertissements de dépendance retardés
• Les enquêtes redondantes
• Les vérifications d'état constantes

Mais cela n'élimine pas le travail d'intégration.

Les sessions indépendantes peuvent toujours :

• Produire des modifications conflictuelles
• Mal interpréter les messages
• Utiliser un état du dépôt obsolète
• Arriver à des conclusions techniques différentes
• Transmettre des découvertes erronées à une autre session

Le développeur a toujours besoin de tests, de revues de code, de contrôle de version et de limites de permissions appropriées.

Bonnes pratiques pour la messagerie inter-sessions

En pratique, certaines habitudes peuvent rendre cette fonctionnalité plus fiable.

Garder les messages ciblés

Un message utile doit indiquer :

• Ce qui a changé
• Pourquoi c'est important
• Quel composant est affecté
• Ce qu'une autre session doit vérifier

Par exemple :

La migration de base de données a renommé `billing_customer_id` en `customer_id`.
Votre branche contient encore deux requêtes qui référencent l'ancien champ.
Veuillez mettre à jour ces requêtes avant d'effectuer les tests d'intégration.

C'est mieux que :

J'ai modifié des trucs dans la base de données. Vérifiez.

Ne pas considérer les messages comme une mémoire partagée

La session réceptrice n'hérite pas de tout le raisonnement de l'expéditeur.

Si une découverte dépend d'un fichier, d'un commit, d'un journal ou d'un résultat de test, identifiez-le explicitement.

Utiliser des worktrees pour les modifications de code en parallèle

Lorsque plusieurs sessions modifient activement le même dépôt, des worktrees Git isolés peuvent réduire les conflits de fichiers.

La messagerie inter-sessions peut coordonner les branches, tandis que Git continue de gérer l'historique du code et les fusions.

Garder l'approbation humaine pour les opérations à haut risque

La messagerie entre agents est utile pour coordonner le travail.

Elle ne doit pas devenir un moyen de contourner les mécanismes suivants :

• Approbations de déploiement
• Contrôles d'accès à l'environnement de production
• Commandes destructrices
• Revues de sécurité
• Opérations financières

La conception des permissions d'Anthropic garantit déjà qu'un message ne peut pas remplacer une approbation utilisateur. Les équipes doivent maintenir cette séparation dans des flux de travail plus larges.

Mettre à jour au-delà de la version minimale

La v2.1.224 a introduit cette fonctionnalité, mais les versions ultérieures ont corrigé le comportement de traitement des messages et amélioré la communication entre machines.

Sauf si un déploiement d'entreprise nécessite une version figée, utiliser la version prise en charge la plus récente est un choix plus sûr.

Questions fréquentes

Qu'est-ce que la messagerie inter-sessions de Claude Code ?

La messagerie inter-sessions permet à une session Claude Code indépendante d'envoyer des messages texte à une autre session. Elle est conçue pour la coordination entre sessions travaillant en parallèle, comme la transmission de découvertes, le signalement de l'état des tâches ou l'avertissement d'une autre session d'un changement à venir potentiellement destructeur.

Quelle version de Claude Code a introduit la messagerie inter-sessions ?

Cette fonctionnalité a été introduite dans Claude Code v2.1.224, publiée le 7 août 2026. La documentation actuelle d'Anthropic exige la version v2.1.224 ou supérieure.

La messagerie inter-sessions partage-t-elle l'intégralité de la conversation Claude ?

Non. La session réceptrice ne reçoit que le texte du message, l'identité de l'expéditeur et généralement une adresse de réponse — pas l'historique de conversation ni les fichiers de l'expéditeur. Pour poursuivre un contexte de conversation complet, utilisez la fonction de reprise de session.

Les sessions Claude Code peuvent-elles s'envoyer des messages entre ordinateurs ?

Oui, les sessions prises en charge peuvent communiquer entre machines via l'infrastructure de contrôle à distance d'Anthropic. Anthropic précise que pour démarrer une nouvelle conversation par nom avec une session sur une autre machine, la version v2.1.225 ou supérieure est requise ; le comportement inter-machines de la v2.1.224 est plus limité.

La messagerie inter-sessions prend-elle en charge Windows ?

Elle prend en charge macOS et Linux, y compris Linux sous WSL 2. La documentation actuelle d'Anthropic indique que cette fonctionnalité n'est pas disponible sur Windows natif.

Les messages sur la même machine passent-ils par les serveurs d'Anthropic ?

Non. Anthropic indique que les messages envoyés entre sessions sur la même machine utilisent des sockets locaux par session et ne passent pas par les serveurs d'Anthropic.

Une session Claude peut-elle approuver une demande de permission d'une autre session ?

Non. Un message entrant inter-sessions ne compte jamais comme un consentement utilisateur. Il ne peut pas non plus forcer une autre session à modifier des permissions protégées ou des paramètres de configuration.

Comment mettre à jour Claude Code ?

Pour une installation native, exécutez claude update, puis redémarrez Claude Code. Vous pouvez vérifier la version installée avec claude --version et diagnostiquer l'état de la mise à jour avec claude doctor.

Outils associés

• Claude Code : l'environnement de codage agentique d'Anthropic pour l'exploration de codebase, l'implémentation, le débogage, les tests et les tâches logicielles à plus long terme.
• Messagerie inter-sessions Claude Code : guide officiel d'Anthropic sur la découverte de sessions, la livraison, la messagerie inter-machines, le contrôle entrant et les limitations.
• Équipes d'agents Claude Code : multi-agents coordonnés d'Anthropic

adaptés aux flux de travail de tâches générées et supervisées par Claude.

• Git Worktree : mécanisme officiel de Git pour maintenir plusieurs arbres de travail à partir d'un seul dépôt, adapté aux sessions Claude Code en parallèle.

Contrôle à distance de Claude Code : la fonctionnalité d'Anthropic permettant de piloter une session Claude Code depuis un autre appareil.

• Journal des mises à jour de Claude Code : historique officiel des versions des fonctionnalités, correctifs et dates de publication de Claude Code.

Liens connexes

• Documentation sur la messagerie inter-sessions : explication faisant autorité sur la manière dont les sessions se découvrent mutuellement et s'envoient des messages.
• Journal des mises à jour de Claude Code : confirmation que la version v2.1.224 a été publiée le 7 août 2026 et a ajouté la fonctionnalité SendMessage inter-sessions.
• Installation et mise à jour de Claude Code : guide officiel d'installation, des canaux de mise à jour, des gestionnaires de paquets et de la commande claude update.
• Référence de l'interface CLI de Claude Code : référence officielle des commandes claude, claude update, claude install et claude agents.
• Paramètres de Claude Code : référence officielle des paramètres, y compris la configuration et les contrôles au niveau organisationnel.
• Documentation sur Git Worktree : guide officiel de Git pour la création d'arbres de travail isolés afin de prendre en charge le développement parallèle.
• Documentation de Claude Code : centre de documentation principal d'Anthropic sur les flux de travail et les fonctionnalités de Claude Code.

Résumé

Claude Code v2.1.224 a introduit la fonctionnalité de messagerie inter-sessions, permettant à des sessions Claude Code indépendantes de se découvrir mutuellement et de s'envoyer des messages texte. Cette fonctionnalité est conçue pour le travail en parallèle : transmettre les résultats de découverte, coordonner les arbres de travail, recevoir des mises à jour de tâches de longue durée, et réduire le besoin pour les développeurs de relayer manuellement des informations entre plusieurs terminaux.

L'implémentation est volontairement limitée en termes de fonctionnalités. Les messages ne contiennent pas d'historique complet de conversation ni de fichiers, une session ne peut pas approuver des autorisations pour une autre session, et les messages entrants peuvent être acceptés, mis en attente ou rejetés. Sur une même machine, les messages restent transmis localement via le socket de chaque session.

Les versions ultérieures ont optimisé la fonctionnalité d'origine. En particulier, la version v2.1.225 a amélioré l'établissement de connexions entre machines et corrigé les scénarios de traitement des messages dans les sessions sans tête (headless).

La véritable amélioration ne réside pas seulement dans le fait que deux fenêtres Claude peuvent « discuter » — mais dans le fait que des agents de codage indépendants peuvent désormais coordonner leur travail sans que le développeur serve de bus de messages entre chaque tâche parallèle.