Tmux pour les Agents IA : Modèles 2026

Tmux pour l'orchestration d'agents IA : modèles de développement parallèle 2026

Tmux, lancé en 2007 comme multiplexeur de terminal client-serveur, est désormais l'outil incontournable des développeurs confirmés gérant entre 4 et 8 agents IA parallèles tels que Claude Code, Codex CLI ou Gemini CLI. À la place des interfaces graphiques, les équipes utilisent des scripts bash purs et des fenêtres tmux—chaque fenêtre dédiée à un agent ou à un worktree git. Cette méthode évite la perte de contexte, les conflits git et la surcharge cognitive. Nous explorons trois modèles éprouvés tirés de Hacker News : les plans fonctionnels, le fork d'agents et l'intégration avec les worktrees git.

Le modèle des Plans Fonctionnels : spécifications structurées + agents exécutants

Manuel Schipper (ingénieur IA senior, Snowflake) délègue 90 % du développement à des agents IA via des spécifications structurées appelées Plans Fonctionnels (FD). Chaque fenêtre tmux joue un rôle distinct :

• Planificateur : génère les FD à partir d'énoncés de problème.
• Exécutant : implémente les fonctionnalités selon les FD.
• Chef de projet : gère la liste de tâches.

Les FD sont numérotés (ex. FD-001…), stockés dans docs/features/ et suivent cette structure :

• Problème : description claire du problème.
• Solutions : plusieurs options avec leurs avantages/inconvénients.
• Solution choisie : plan d’implémentation et liste des fichiers.
• Vérification : étapes pour valider la correction.

Exemple FD-051 :

FD-051 : Classification multi-étiquette de documents
Statut : Ouvert
Priorité : Moyenne
Effort : Moyen
Impact : Meilleure couverture

## Problème
Les documents entrants reçoivent une seule étiquette, mais beaucoup traitent plusieurs sujets.

## Solution
1. Scores de confiance LLM par catégorie.
2. Accepter >0,90.
3. Deuxième passe pour 0,50–0,90.
4. Stockage avec scores.

## Fichiers
- src/classify/multi_label.py
- src/classify/prompts.py
- sql/01_schema.sql

## Vérification
1. Exécuter en staging.
2. Contrôles de santé.
3. Vérification manuelle.

Cycle de vie : Planifié → Conçu → Ouvert → En cours → En attente de vérification → Terminé. Automatisation via six commandes slash :

• /fd-new : créer un nouveau FD.
• /fd-status : afficher un index de tous les FD.
• /fd-explore : charger le contexte dans la session courante.
• /fd-deep : lancer quatre agents parallèles (algorithmes/structure/incrément/environnement).
• /fd-verify : relire et valider les modifications.
• /fd-close : archiver les FD terminés.

La commande /fd-deep exploite les principes de calcul au moment des tests en lançant simultanément quatre agents pour générer des idées. Au fil des mois, les équipes produisent plus de 300 FD. Initialisation : /fd-init configure l’infrastructure complète.

Compromis : les agents compressent le contexte, perdant certains détails fins—Schipper rédige manuellement des points de contrôle en Markdown pour préserver la clarté.

Modèle de Fork d'agents : forks spécifiques au contexte

Kaushik Gopal (ingénieur principal, Instacart) propose un modèle sans plan préalable. Dans la session courante, capturez le contenu du panneau (tmux capture-pane), enveloppez-le dans <context>, puis lancez-le dans une nouvelle fenêtre.

Le script bash est minimal et indépendant des outils : fork de Claude vers Gemini pour générer des diagrammes. Interactivement, vous copiez manuellement le contenu nécessaire.

Avantages :

• Faible surcharge — fork uniquement quand nécessaire.
• Workflow inter-agents : Codex → Claude → Gemini.

Inconvénients :

• Pas de fusion automatique.
• Forks longs (>1 heure) risquent de se désynchroniser avec la branche principale.

Cas d’usage : explorer des hypothèses tangentes ou tester des fonctionnalités en parallèle. Script disponible sur Gist — seulement 20 lignes.

Worktree Git + Tmux : isolation par répertoire

Syo Ito résout les conflits git en attribuant un worktree git par agent et une fenêtre tmux par worktree. Les noms de fenêtres correspondent aux noms des worktrees.

Évitez le chaos des panneaux : ne divisez pas les panneaux par worktree. Utilisez une fenêtre par worktree, avec des panneaux pour le shell et Vim.

Outil utile kage : kage feat-x crée un worktree, une fenêtre tmux et lance Claude Code.

Exemple de script agent-worker :

#!/usr/bin/env bash
set -euo pipefail
WORKTREE_NAME="${1:?}"
FD_NUMBER="${2:?}"
WT_PATH="$(git rev-parse --show-toplevel)/../${WORKTREE_NAME}"

git worktree add "$WT_PATH" -b "feat/${WORKTREE_NAME}"
tmux new-window -n "$WORKTREE_NAME" -c "$WT_PATH" \
  "claude --permission-mode acceptEdits 'implement FD-${FD_NUMBER}'"

Configuration minimale tmux pour agents

# Préfixe C-a
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Numérotation commence à 1
set -g base-index 1
setw -g pane-base-index 1

# Support souris
set -g mouse on

# Taille de l'historique
set -g history-limit 50000

# Navigation panneaux style Vim
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

set -g renumber-windows on

Points clés

• Max 4 à 8 agents : au-delà, la concentration baisse et la qualité du résultat diminue.
• Worktree git obligatoire : indispensable pour éviter les conflits avec 3+ agents.
• Une fenêtre par agent : éviter l’éparpillement des panneaux qui perturbe la navigation.
• Points de contrôle manuels en Markdown : compenser la perte de contexte due à la compression.
• Bash + Tmux : zéro dépendance, entièrement indépendant des outils.

— Editorial Team