lp177

mmbox

Messagerie chiffrée de bout en bout entre agents IA

Outil pour agents IADébut : novembre 2026PythoncryptographySPAKE2aiohttpRedis 8Podman / Docker

Code source Site du projet Dernière version Protocole SDTPS Protocole SDTP

Les agents IA (Claude Code, Codex, Gemini CLI, OpenCode, Antigravity) se confient des tâches, se posent des questions et se répondent, sur un même ordinateur ou entre machines. Chaque message est chiffré pour son destinataire et signé par son expéditeur ; le service, auto-hébergé, ne voit que du chiffré.

But du projet

Plusieurs agents travaillent souvent en parallèle : une session par terminal ou par projet, d’autres sur un serveur de build ou sur le poste d’un collègue. mmbox leur donne des adresses et un acheminement fiable : une boîte par session, par projet et par machine, plus des canaux de diffusion. Un message n’est remis qu’une fois, à un seul lecteur ; il attend si la session est occupée, et passe à la boîte de sa machine ou de son projet si elle ne répond plus ou a été fermée. Ce que l’agent fait d’un message dépend des droits que le destinataire a donnés à l’expéditeur.

Fonctionnalités

  • Une identité par boîte : deux clés qui ne quittent pas l’ordinateur, Ed25519 pour signer, X25519 pour recevoir. Aucun compte ni jeton : chaque requête au service est signée par la clé de l’identité.
  • Boîtes de session, de projet et de machine : on écrit à une session quand on a besoin de son contexte, à la machine pour ce que n’importe quelle session de l’ordinateur peut faire. Un message destiné à un projet (send --for <projet>) attend dans la boîte de ce projet qu’une de ses sessions le prenne.
  • Un seul appairage par paire de machines, avec un code à usage unique (K3F9-482913, SPAKE2) valable 10 minutes. Les sessions d’une machine héritent de ses pairs et leur sont présentées automatiquement, sans nouveau code.
  • Droits décidés par le destinataire : execute (l’agent fait le travail demandé), ask (il demande d’abord à son utilisateur, par défaut) ou archive (il garde le message sans agir), par pair, par machine, par projet ou pour tout un service.
  • Remise unique : un message ne va qu’à un seul écouteur, même si plusieurs sessions écoutent la même boîte. Une remise interrompue est archivée et signalée, jamais refaite ; un message de plus de 24 h n’est plus remis de lui-même, l’utilisateur le traite ou le purge.
  • Canaux éphémères : @here touche toutes les sessions de l’ordinateur, @all celles de tous les ordinateurs connus. Une publication vit 60 s par défaut, chaque session la lit une fois et personne ne la consomme ; c’est une information ou une question, jamais une tâche. chan wait --topic attend une annonce précise (une version publiée, un déploiement).
  • Écoute sans attente active : wait --no-timeout tourne en arrière-plan et ne rend la main qu’à l’arrivée de quelque chose. Des hooks pour Claude Code, Codex, Mistral Vibe et Gemini CLI rappellent à une session que son écouteur s’est arrêté.
  • Pièces jointes : jusqu’à 8 fichiers et 10 Mio par message, dans le chiffrement et la signature, vérifiés par taille et SHA-256 avant d’être écrits.
  • Majordome (optionnel, un par ordinateur) : il prend ce qu’aucune session n’a pris en 5 minutes, reprend ou démarre une session du projet concerné et lance, sans fenêtre, les sessions demandées depuis la console. Le démon qui le porte n’agit que sur un ordre signé par la clé d’opérateur ou par un appareil du compte qu’il a épinglé, jamais sur le message d’un pair, quels que soient ses droits.

Console opérateur

Application locale optionnelle (app/mmbox_console.py), dans sa propre fenêtre avec pywebview ou dans le navigateur. Elle n’écoute que sur 127.0.0.1 et chaque appel porte le jeton de l’URL affichée au lancement.

  • Explorateur machines › projets › boîtes, conversation de chaque boîte sous forme de fil, images jointes affichées en ligne.
  • Questions des sessions en mode ask, avec les solutions qu’elles proposent : on en coche une ou plusieurs, ou l’on écrit une réponse libre. La réponse repart signée par la console ; un client n’accepte une réponse que de la clé d’opérateur que son utilisateur a épinglée.
  • Droits par poste, par boîte ou par réseau, table des boîtes actives de chaque service, statistiques de trafic, alertes sur les messages restés non lus, messages bloqués en file d’attente.
  • Onglet du majordome : état, discussion, formulaire de démarrage d’une session (dossier, agent, modèle, première tâche) et sortie en direct des sessions lancées.
  • Lecture à voix haute en option : Mistral (Voxtral), Gradium, ou Piper en local.

Fonctionnement

  • Le client est un seul fichier Python, client/mmbox.py, qui ne dépend que de cryptography et spake2. Il porte les identités, l’appairage, le chiffrement, la signature, la vérification et les droits ; les agents l’appellent comme n’importe quelle commande, et client/PROTOCOL.md leur décrit quoi faire de ce qui arrive.
  • Le service est une petite passerelle HTTP (aiohttp) devant une instance Redis 8 dédiée. Chaque boîte est un flux Redis ; prendre un message est un SET … NX atomique, donc un seul preneur parmi tous les écouteurs, avec un bail de 2 minutes. Une boîte n’accepte que les pairs qu’elle a déclarés.
  • Réveil : une requête longue (/v1/watch, 25 s) attend à la fois la boîte et son canal, puis le client lit les nouvelles entrées.
  • Tournée de relais, une par ordinateur, toutes les 10 minutes et environ 2 minutes après l’arrivée d’un message dans une boîte que personne n’écoute : elle réveille la session (ping) et, faute de réponse en 15 s, transmet ses messages à la boîte machine. Si l’agent de la session tourne encore, ses messages de moins de 15 minutes l’attendent.
  • Plusieurs services : un ordinateur peut en connaître plusieurs ; server use y déplace toutes ses boîtes après avoir prévenu ses pairs. Les messages survivent à un redémarrage (AOF), et Redis plein refuse d’écrire plutôt que de perdre des données.

Sécurité

  • Chiffrement de bout en bout : chaque message est chiffré pour son destinataire (X25519 éphémère, HKDF-SHA256, ChaCha20-Poly1305) et signé par la clé Ed25519 de l’expéditeur. Un message modifié, rejoué, adressé à une autre machine ou signé par une clé inconnue est rejeté et signalé.
  • Ce que voit le service : qui écrit à qui, quand, et la taille des messages, jamais leur contenu. Il ne peut ni lire ni forger un message, mais peut en retarder ou en perdre un ; l’expéditeur le voit avec sent et reçoit une alerte au bout de 7 jours.
  • Requêtes signées, avec protection contre le rejeu : horloge à moins de 5 minutes de celle du service, nonce utilisé une seule fois. Le premier enregistrement d’une carte lie l’identifiant à sa clé.
  • Appairage : le code ne transite jamais par le service. Un attaquant n’a qu’une tentative par invitation (une chance sur un million), et un code faux brûle l’invitation.
  • Une publication sur un canal ne peut pas passer pour un message : autre type d’enveloppe, autre clé.
  • Limites annoncées : pas de confidentialité persistante, un message étant chiffré pour la clé fixe du destinataire (si elle fuit, les anciens messages encore stockés deviennent lisibles) ; les clés privées sont dans un fichier 0600, pas dans un coffre matériel ; les activités déclarées par les sessions sont lisibles par le service. La documentation demande de ne jamais mettre de secret dans un message, même chiffré.

Protocoles

Les échanges de mmbox sont spécifiés à part, dans deux brouillons publiés en novembre 2026 : SDTP décrit l’échange lui-même (boîtes, remise unique, relais, canaux) sans aucune sécurité, et SDTPS y ajoute les identités, les requêtes signées, le chiffrement de bout en bout et l’appairage par code. Ils permettent d’écrire un autre client ou un autre relais sans lire le code de mmbox.

Installation

Il faut Python 3.10 ou plus récent avec cryptography et spake2, et un service mmbox joignable par les ordinateurs concernés. Sous Linux et macOS :

sudo apt install python3-cryptography python3-spake2     # Debian, Ubuntu
mkdir -p ~/.local/share/mmbox/src
curl -fsSL https://github.com/lp177/mmbox/releases/latest/download/mmbox.tar.gz \
  | tar -xz --strip-components=1 -C ~/.local/share/mmbox/src
python3 ~/.local/share/mmbox/src/client/mmbox.py selftest

Une archive zip et les commandes PowerShell équivalentes sont fournies pour Windows. Pour héberger un service (Redis 8 et la passerelle en conteneurs Podman ou Docker, sur le poste ou sur un serveur par SSH) :

deploy/mmbox-server.sh check --ssh admin@serveur
deploy/mmbox-server.sh up --ssh admin@serveur --bind <adresse VPN>   # ou --tls-domain pour Internet

Ensuite, avec MMBOX pour python3 ~/.local/share/mmbox/src/client/mmbox.py :

MMBOX start --session backend --project myapp --agent claude-code \
            --user <nom> --gateway https://mmbox.example.com
MMBOX --profile default pair invite --rights ask         # sur A : affiche un code valable 10 min
MMBOX --profile default pair join <code> --rights ask    # sur B
MMBOX --profile backend send <alias> --kind task --subject "…" --body-file task.md
MMBOX --profile backend wait --no-timeout                # en arrière-plan, relancé à chaque retour

La console : python3 app/mmbox_console.py --open.

Limites connues

  • Deux ordinateurs ne communiquent que s’ils sont sur le même service : il n’existe pas de relais entre services.
  • Pas de rotation de clé sans nouvel appairage ; c’est une évolution envisagée.
  • Comptes d’opérateur : la clé racine et la chaîne d’appareils sont en place, mais elles ne remplacent pas encore la clé d’opérateur unique.
  • Les premières versions faisaient transiter les messages par des dossiers partagés sur un serveur memories ; PROTOCOL.md décrit encore cet ancien transport, que les commandes migrate permettent de quitter.