Guía para Desarrolladores sobre tmux en la Era de la IA

tmux es un multiplexor de terminal: ejecuta un proceso servidor persistente en tu máquina para que las sesiones, ventanas y paneles sobrevivan a las desconexiones del terminal — puedes desconectarte de una sesión, cerrar tu laptop, reconectarte por SSH desde otra máquina y volver a encontrar cada proceso exactamente donde lo dejaste. Esa única propiedad es la razón por la que tmux importa más ahora que hace una década: los desarrolladores ejecutan cada vez más procesos de larga duración — servidores de desarrollo, observadores de compilación y agentes de codificación IA autónomos como Claude Code y aider — que necesitan sobrevivir a una conexión SSH inestable o a un equipo cerrado.

Esta guía construye primero el modelo mental (sesiones, ventanas, paneles, la tecla prefijo), te proporciona una configuración mínima que puedes pegar una sola vez y olvidar, y luego dedica tiempo real a la parte que ninguna otra guía de tmux cubre: usar tmux como anfitrión duradero para agentes de codificación IA. Cierra con una comparación honesta de cuándo recurrir a tmux y cuándo un terminal moderno como Zellij o Warp es la mejor herramienta.

Qué es tmux y el Problema que Resuelve

tmux es un multiplexor de terminal que permite que una sola ventana de terminal aloje múltiples sesiones, ventanas y paneles persistentes. El mecanismo detrás de su persistencia es una arquitectura cliente-servidor: cuando ejecutas tmux, inicia un proceso servidor de larga duración que gestiona tus sesiones, y tu terminal se conecta a ese servidor como cliente. Cuando tu conexión SSH se interrumpe, tu sesión de tmux no lo hace — porque el proceso servidor se ejecuta de forma independiente a cualquier conexión de cliente. Tu terminal es simplemente una vista; la sesión continúa ejecutándose tanto si estás conectado como si no.

tmux resuelve dos problemas a la vez. El primero es la persistencia: una compilación que tarda 40 minutos, un servidor de desarrollo o un agente IA en mitad de una tarea siguen ejecutándose después de que tu sesión ssh muera. Te reconectas y vuelves a adjuntarte. El segundo es el diseño: en lugar de gestionar pestañas de terminal, divides una ventana en paneles — el editor a la izquierda, un registro del servidor a la derecha, una shell en la parte inferior — todos visibles a la vez y todos reproducibles.

tmux fue creado en 2007 por Nicholas Marriott como una alternativa con licencia ISC a GNU screen. Los ejemplos de esta guía utilizan tmux 3.6b. Instálalo con tu gestor de paquetes:

# macOS
brew install tmux

# Debian / Ubuntu / WSL
sudo apt install tmux

# Fedora / RHEL
sudo dnf install tmux

tmux -V   # confirmar la versión

La Jerarquía de Sesiones, Ventanas y Paneles

tmux organiza el trabajo en tres capas: una sesión es un espacio de trabajo nombrado y persistente (uno por proyecto); las ventanas son pestañas dentro de esa sesión; los paneles son divisiones dentro de una ventana. La tecla prefijo — Ctrl+b por defecto, convencionalmente reasignada a Ctrl+a — controla cada comando de tmux. Presionas el prefijo, lo sueltas y luego presionas la tecla de comando.

La analogía más clara se corresponde con un editor que ya conoces: una sesión es como toda una ventana del editor para un proyecto, las ventanas son las pestañas dentro de ella, y los paneles son las vistas divididas dentro de una pestaña. Podrías tener una sesión frontend y una sesión backend; dentro de backend, una ventana para la aplicación y otra para la base de datos; dentro de la ventana de la aplicación, un panel ejecutando el servidor y otro para comandos ad-hoc.

Dado que el prefijo controla los comandos, todos los atajos de teclado que aparecen a continuación asumen que presionas el prefijo primero. El prefijo predeterminado es Ctrl+b; la configuración de la siguiente sección lo reasigna a Ctrl+a, que es más fácil de alcanzar.

El Conjunto de Comandos Esenciales

Estos comandos cubren el 90% del uso diario de tmux: crear y nombrar sesiones, desconectarse y volver a conectarse, dividir y navegar por paneles, y desplazarse por el historial de salida. Los comandos a nivel de sesión se ejecutan desde tu shell; los comandos de panel y ventana se ejecutan dentro de tmux mediante el prefijo.

Gestión de sesiones desde la shell:

tmux new -s project       # crear una sesión con nombre
tmux ls                   # listar sesiones en ejecución
tmux attach -t project    # volver a conectarse a una sesión
tmux kill-session -t project

Dentro de una sesión, con el prefijo (mostrado aquí como el Ctrl+a reasignado):

• prefix d — desconectarse; la sesión continúa ejecutándose en segundo plano.
• prefix c — crear una nueva ventana.
• prefix n / prefix p — ventana siguiente / anterior.
• prefix % — dividir el panel actual verticalmente (izquierda/derecha).
• prefix " — dividir horizontalmente (arriba/abajo).
• prefix + teclas de dirección — moverse entre paneles.
• prefix z — ampliar el panel actual a pantalla completa; presionar de nuevo para restaurar.
• prefix [ — entrar en modo de copia para desplazarse y buscar; en modo vi, / busca, n/N salta entre coincidencias, q sale.

El ciclo de desconexión/reconexión es el flujo de trabajo central: desconéctate con prefix d, cambia a otra máquina, vuelve a conectarte con tmux attach -t nombre-proyecto, y retoma exactamente donde lo dejaste. Para una referencia completa de atajos de teclado, ten a mano una hoja de referencia de tmux — memorizar toda la página del manual no es necesario.

Una Configuración Mínima ~/.tmux.conf que Puedes Pegar una Sola Vez

Una configuración mínima de tmux necesita exactamente cuatro cosas: una tecla prefijo reasignada (Ctrl+a es más ergonómica que Ctrl+b), soporte para ratón (set -g mouse on), modo de copia vi y atajos de división intuitivos — todo lo demás es cosmético y puede esperar. Aquí está esa configuración, con un comentario en cada línea que explica por qué existe. Pégala en ~/.tmux.conf y recárgala con tmux source-file ~/.tmux.conf.

# --- prefix -------------------------------------------------
unbind C-b                 # eliminar el prefijo predeterminado
set -g prefix C-a          # Ctrl+a está más cerca de la fila base
bind C-a send-prefix       # presionar Ctrl+a dos veces envía un Ctrl+a literal

# --- usabilidad ---------------------------------------------
set -g mouse on            # hacer clic en paneles, arrastrar bordes, desplazarse de forma nativa
set -g history-limit 10000 # mantener más historial de desplazamiento que el predeterminado de 2000
set -g base-index 1        # numerar ventanas desde 1, no desde 0
setw -g pane-base-index 1  # numerar paneles desde 1 también

# --- modo de copia ------------------------------------------
setw -g mode-keys vi       # teclas vi en modo de copia
bind v copy-mode           # prefix v para entrar en modo de copia rápidamente

# --- divisiones más intuitivas ------------------------------
bind | split-window -h -c "#{pane_current_path}"  # | divide izquierda/derecha
bind - split-window -v -c "#{pane_current_path}"  # - divide arriba/abajo
# ambas abren en el directorio del panel actual

# --- recarga ------------------------------------------------
bind r source-file ~/.tmux.conf \; display "reloaded"

Algunas notas sobre la sintaxis y las versiones. set -g mouse on es la forma correcta de opción única para tmux 2.1 y posteriores; tmux 2.1 (2015) consolidó las cuatro opciones anteriores (mode-mouse, mouse-select-pane, mouse-resize-pane, mouse-select-window) en una sola. Si encuentras una configuración antigua que usa mode-mouse on, esa es la razón por la que se ve diferente. El indicador -c "#{pane_current_path}" hace que las nuevas divisiones hereden el directorio actual — algo pequeño que echarás de menos inmediatamente si no está presente.

Esa es toda la configuración. Resiste la tentación de añadir un tema de barra de estado el primer día. Si más adelante quieres uno, el plugin Catppuccin para tmux (etiqueta actual v2.3.0) requiere tmux 3.2+, y su README recomienda una clonación manual sobre el gestor de plugins debido a un conflicto de nombres.

Flujos de Trabajo Modernos: tmux como Anfitrión para Agentes de Codificación IA

tmux es el anfitrión natural para agentes de codificación IA de larga duración. Desconéctate de una sesión de Claude Code o aider antes de cerrar tu laptop, vuelve a conectarte desde cualquier máquina con tmux attach -t agent, y el proceso del agente — junto con todo su historial de salida — te estará esperando. Tanto Claude Code como aider son CLIs de terminal, por lo que esto no es una integración especial: es el comportamiento estándar de cualquier proceso en primer plano ejecutándose bajo una sesión de tmux, aplicado a una herramienta que puede ejecutarse durante muchos minutos sin supervisión.

Las sesiones de codificación agéntica son exactamente la carga de trabajo que tmux fue diseñado para proteger. Un agente refactorizando una base de código grande o ejecutando un ciclo de pruebas largo es un proceso que no quieres que esté vinculado a la duración de tu conexión SSH. Inícialo dentro de tmux y sobrevivirá a la interrupción.

Supervisar un Agente Mientras Trabajas

El diseño más útil es tener un agente en un panel y un editor en otro, uno al lado del otro. Inicia una sesión, divídela y ejecuta el agente en un lado:

tmux new -s agent
# dentro de la sesión:
#   prefix |   -> dividir izquierda/derecha
#   panel izquierdo:  claude   (o: aider)
#   panel derecho: nvim .

Observas el razonamiento y los diffs del agente a la izquierda mientras revisas o editas a la derecha, todo en una ventana, todo sobreviviendo a las desconexiones.

Supervisar Múltiples Agentes con Paneles Sincronizados

Cuando ejecutas varios agentes en paralelo — por ejemplo, la misma tarea en diferentes ramas — los paneles sincronizados te permiten controlarlos conjuntamente. Con setw -g synchronize-panes on, cada pulsación de tecla que escribes se envía a todos los paneles de la ventana simultáneamente, lo que resulta útil para emitir el mismo prompt a múltiples sesiones de agentes o para reiniciar un conjunto de procesos paralelos a la vez. Desactívalo de la misma manera (synchronize-panes off) cuando quieras interactuar con un solo panel. Un error común que cometemos con los paneles sincronizados es olvidar que la sincronización está activada y transmitir un comando destructivo a todos los paneles — asígnalo a una tecla con un indicador visible para que su estado nunca sea ambiguo.

Un Diseño de Agente con Script

Para obtener un diseño reproducible de supervisión con tres paneles — agente a la izquierda, editor arriba a la derecha, registros abajo a la derecha — sin ninguna dependencia adicional, coloca este script en ~/bin/tmux-agent.sh:

#!/usr/bin/env bash
set -euo pipefail
SESSION="agent"

# Primer panel: el agente (izquierda). -d crea la sesión desconectada.
tmux new-session -d -s "$SESSION" -x "$(tput cols)" -y "$(tput lines)"
tmux send-keys -t "$SESSION" "claude" C-m          # agente, izquierda

# Dividir el lado derecho para el editor; el nuevo panel se vuelve activo.
tmux split-window -h -t "$SESSION"
tmux send-keys -t "$SESSION" "nvim ." C-m          # editor, arriba a la derecha

# Dividir el panel derecho para los registros; el nuevo panel se vuelve activo.
tmux split-window -v -t "$SESSION"
tmux send-keys -t "$SESSION" "tail -f dev.log" C-m # registros, abajo a la derecha

# Enfocar el panel del agente y conectarse. Usar dirección (-L) en lugar de
# índices de panel codificados de forma fija mantiene esto correcto
# independientemente de tu base-index.
tmux select-pane -t "$SESSION" -L
tmux attach -t "$SESSION"

Ejecuta chmod +x ~/bin/tmux-agent.sh una vez, luego tmux-agent.sh cada vez que comiences a trabajar. El agente continúa ejecutándose si te desconectas; vuelve a conectarte desde cualquier lugar.

Persistencia y Plugins

Las sesiones de tmux sobreviven a las desconexiones, pero no sobreviven a un reinicio por sí solas — para eso necesitas plugins que serialicen y restauren el estado. La pila estándar es el Tmux Plugin Manager (TPM) junto con tmux-resurrect y tmux-continuum. Instala TPM con:

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Luego añade las líneas de plugins al final de ~/.tmux.conf y presiona prefix + I para instalarlos:

set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
run '~/.tmux/plugins/tpm/tpm'   # mantener esta línea al final

Comprende qué hace realmente cada plugin. tmux-resurrect guarda y restaura el diseño de tu sesión — ventanas, paneles y directorios de trabajo — automáticamente. La restauración de los programas que estaban en ejecución es opcional y está limitada a una lista blanca configurada (@resurrect-processes), con las sesiones del editor gestionadas por @resurrect-strategy-vim/nvim y el texto del panel preservado solo cuando se establece @resurrect-capture-pane-contents 'on'. No asumas que tu agente se reinicia solo al restaurar; no lo hará a menos que lo hayas incluido en la lista blanca.

tmux-continuum automatiza el guardado cada 15 minutos por defecto (configurable mediante @continuum-save-interval) y restaura al iniciar el servidor de tmux solo cuando @continuum-restore 'on' está habilitado. Juntos significan que un reinicio te cuesta una recarga del diseño, no una reconstrucción desde cero.

Diseños Declarativos con tmuxp

Para diseños que lanzas repetidamente, defínelos una vez en YAML con tmuxp (repositorio: tmux-python/tmuxp) o el basado en Ruby Tmuxinator. tmuxp lee las configuraciones desde el directorio XDG ~/.config/tmuxp/ (la ruta heredada ~/.tmuxp/ sigue funcionando). Aquí está el diseño de supervisión del agente como ~/.config/tmuxp/agent.yaml:

session_name: agent
windows:
  - window_name: supervise
    layout: main-vertical
    shell_command_before:
      - cd ~/code/project
    panes:
      - claude
      - nvim .
      - tail -f dev.log

Cárgalo con tmuxp load agent. Las claves aquí — session_name, windows, window_name, layout, shell_command_before, panes — están todas vigentes en tmuxp 1.70.x. Este es el equivalente declarativo del script bash anterior: un solo comando, el mismo diseño reproducible cada vez.

Cuándo NO Usar tmux

Si trabajas localmente y no te conectas por SSH a máquinas remotas ni ejecutas procesos en segundo plano de larga duración, un terminal moderno como Zellij o Warp te ofrece multiplexación con mejores valores predeterminados y sin la curva de aprendizaje de la tecla prefijo; la ventaja de tmux es específicamente su persistencia del lado del servidor y su capacidad de scripting sobre SSH. Recurrir a tmux cuando las pestañas nativas de tu terminal serían suficientes añade complejidad sin ningún beneficio.

Algunas notas decisivas. Zellij es un multiplexor basado en Rust con un sistema basado en modos en lugar de una única tecla prefijo, persistencia y serialización de sesiones integradas, y un preset de estilo tmux opcional; está en desarrollo activo y sigue siendo pre-1.0. Warp es un terminal multiplataforma — macOS, Linux y Windows — con sugerencias de comandos integradas con IA, y su cliente fue publicado como código abierto (MIT + AGPL v3) en abril de 2026, por lo que es una opción viable en Linux, no una herramienta exclusiva de macOS. Usa tmux cuando te conectes por SSH a máquinas remotas, ejecutes procesos de larga duración (observadores de compilación, servidores de desarrollo, agentes IA) o necesites diseños reproducibles con script. Usa un terminal moderno cuando quieras esas funciones con menos ceremonia y no necesites la profundidad de scripting o la amplitud de plugins de tmux.

Conclusión

La razón por la que tmux merece un lugar en un flujo de trabajo con muchos agentes es la misma por la que lo mereció sobre SSH hace años: desacopla un proceso en ejecución del terminal que lo observa. Inicia tu próxima ejecución larga de agente dentro de tmux new -s agent, desconéctate cuando te alejes y vuelve a conectarte desde donde estés — el trabajo continúa sin ti. Pega la configuración mínima anterior, añade tmux-resurrect cuando los reinicios empiecen a costarte diseños, y crea el script del diseño del agente una vez para no tener que reconstruirlo manualmente nunca más.

Preguntas Frecuentes

¿Qué ocurre con un proceso que se ejecuta en tmux cuando el servidor de tmux se elimina o la máquina se reinicia?

El proceso se termina. La persistencia de tmux solo protege contra las desconexiones del cliente, no contra el apagado del servidor, por lo que eliminar el servidor con tmux kill-server o reiniciar la máquina termina todos los procesos en ejecución y descarta todas las sesiones. Para sobrevivir a un reinicio necesitas tmux-resurrect para guardar el diseño y tmux-continuum para restaurarlo al iniciar el servidor, pero incluso entonces se restaura el diseño, no los programas en ejecución, a menos que incluyas procesos específicos en la lista blanca mediante la opción resurrect-processes.

¿Cuál es la diferencia entre ventanas y paneles en tmux?

Una ventana es una pestaña a pantalla completa dentro de una sesión, y un panel es una región dividida dentro de una sola ventana. Cambiar de ventana reemplaza toda la pantalla con una pestaña diferente usando prefix n o prefix p, mientras que los paneles dividen una ventana visible en regiones lado a lado o apiladas por las que navegas con prefix y las teclas de dirección. Usa ventanas para separar tareas distintas como una aplicación y su base de datos, y paneles para ver procesos relacionados a la vez, como un editor junto a un registro en tiempo real.

¿Necesito reasignar la tecla prefijo de Ctrl+b a Ctrl+a?

No, la reasignación es opcional y es puramente una elección ergonómica. El prefijo predeterminado Ctrl+b funciona para todos los comandos de tmux sin ninguna configuración. Muchos usuarios lo reasignan a Ctrl+a porque las teclas están más cerca entre sí en el teclado, pero esto entra en conflicto con el mismo atajo en GNU screen y con el atajo de readline que mueve el cursor al inicio de una línea. Si reasignas a Ctrl+a, añade bind C-a send-prefix para que presionarlo dos veces siga enviando un Ctrl+a literal a la shell.

¿Debería usar tmux o Zellij para ejecutar agentes de codificación sobre SSH?

Ambos funcionan porque cada uno ejecuta un servidor en el host remoto que mantiene las sesiones activas durante las desconexiones, por lo que la elección depende de los valores predeterminados y el ecosistema. Elige tmux cuando quieras un ecosistema de plugins grande y maduro, una gran capacidad de scripting mediante bash o tmuxp, y atajos que ya están instalados en la mayoría de los servidores. Elige Zellij cuando prefieras controles basados en modos y descubribles sobre un modelo de tecla prefijo y quieras serialización de sesiones sin configurar plugins. Zellij sigue siendo pre-1.0, por lo que tmux es la opción más conservadora para configuraciones de larga duración.