Los mejores multiplexores de terminal en 2026: tmux vs Zellij vs Rex vs Herdr vs Tern vs TuiOS

La pregunta sobre qué multiplexor de terminal usar solía responderse en cinco segundos: tmux, salvo que estuvieras conectado a una máquina tan vieja que solo tuviera GNU screen. Esa respuesta caducó a mediados de 2026. Los agentes de codificación IA cambiaron para qué sirve realmente un multiplexor. Mantener vivo un shell a través de un enlace SSH inestable solía ser todo el trabajo; ahora el trabajo es mantener vivos a seis agentes repartidos en worktrees de git, saber cuál está bloqueado esperando un permiso y aprobarlo desde un portátil o un teléfono sin rebuscar entre veinte paneles.

Cuatro herramientas serias compiten ahora dentro de tu emulador de terminal (tmux, Zellij, Herdr y TuiOS), más otras dos (Superlogical Rex y Stencil Tern) que defienden que el multiplexor debería ser el propio emulador de terminal.

He ejecutado las seis en proyectos reales y he escrito análisis en profundidad dedicados a la mayoría de ellas. Esta guía pone todo el panorama lado a lado: en qué difieren las arquitecturas, fragmentos de instalación y configuración que puedes pegar esta misma noche, cómo gestiona cada una las flotas de agentes IA, los flujos de trabajo remotos por SSH y desde el teléfono, una tabla de equivalencias de atajos de teclado y dónde sigue doliendo cada herramienta. Todas las capturas de pantalla de abajo están tomadas de mi propia configuración.

Las versiones y el número de estrellas en GitHub se verificaron el 2026-10-29: tmux 3.8 (~49k estrellas), Zellij 0.45.1 (~35.7k estrellas), Herdr 0.9.3 (~44k estrellas), TuiOS 0.11.1 (~5.4k estrellas), Rex en compilación de pruebas públicas y Tern 0.9.5 en beta cerrada.

La versión corta

Si solo quieres la recomendación antes del análisis en profundidad:

• tmux: elígelo si te conectas por SSH a máquinas que no administras, quieres un binario de 1,2 MB que ya está instalado o tienes una década de memoria muscular con .tmux.conf. Sigue siendo la opción por defecto correcta para el trabajo normal de servidor y shell.
• Zellij: elígelo si quieres el trabajo de tmux hecho con valores modernos por defecto: pistas de teclas en pantalla, layouts de proyecto en KDL, resurrección de sesiones integrada, sesiones anidadas de primera clase (v0.45+), plugins en WebAssembly y un cliente web integrado.
• Herdr: elígelo si los agentes de codificación IA son la mayor parte de lo que ejecutas. La barra lateral de estado de agentes en tiempo real (working / blocked / done / idle), la API por socket Unix y el ecosistema de clientes móviles/web son la razón de que exista.
• TuiOS: elígelo si quieres un gestor de ventanas en mosaico dentro de tu terminal más la bandeja de agentes (Inbox) integrada más profunda (retención de prompts, respuestas en cola, revisión de diffs en línea con notas, ejecuciones en worktrees con fan y un shim de tmux) y puedes vivir con un proyecto joven que avanza rápido.
• Rex: elígelo si estás en macOS y quieres el multiplexor integrado en la propia aplicación de terminal, impulsado por libghostty del creador de Ghostty, con inicios de sesión remotos de sistema de primera clase.
• Tern: elígelo si quieres un terminal en Rust multiplataforma donde los paneles también pueden ser clientes git nativos, navegadores de SQLite, cuadernos Jupyter, tableros kanban y bloques de agentes IA, y no te importa una lista de espera de beta cerrada.

Los 6 multiplexores de terminal de un vistazo

Por qué se dividió la arquitectura en 2026: TUI dentro del terminal vs terminal-como-multiplexor

Antes de mirar las herramientas individuales, conviene entender la división estructural de la tabla anterior. Cada herramienta cae en uno de estos dos campos:

1. Los multiplexores dentro del terminal (tmux, Zellij, Herdr, TuiOS) se sitúan entre tu emulador de terminal y el shell: App de terminal → Servidor multiplexor → PTY → Shell/Agente. Como el multiplexor corre dentro de cualquier ventana de terminal, debe mantener su propia máquina de estados de terminal virtual interna, analizar cada secuencia de escape ANSI que emite el programa y luego reemitir las diferencias a tu terminal externo.

   • La ventaja: funciona sobre SSH plano en un VPS Linux headless de 4 $/mes, funciona dentro de Kitty, Ghostty, WezTerm, Alacritty o un cliente SSH de iPhone, y sobrevive a cambios de aplicación de terminal.
   • La desventaja: cada byte se analiza dos veces. Si el analizador interno del multiplexor es más lento que tu terminal con GPU o no entiende una secuencia de escape más nueva (como los gráficos Kitty antes de que llegara el passthrough), el multiplexor se convierte en el cuello de botella.

2. Las aplicaciones terminal-como-multiplexor (Rex, Tern) eliminan la TUI intermediaria. Un demonio en segundo plano posee los PTY (en local o en un servidor remoto), y la aplicación de escritorio, de navegador o móvil es un cliente nativo que se conecta directamente a ese demonio.

   • La ventaja: cero doble análisis, renderizado nativo por GPU (libghostty en Rex, Rust + WebGPU en Tern), scrollback independiente por cliente conectado y paneles que ni siquiera tienen que ser cuadrículas de texto.
   • La desventaja: tienes que usar su aplicación de terminal (o cliente web/móvil) en lugar de ejecutar el multiplexor dentro del emulador de terminal que ya usas.

1. tmux: el veterano

tmux 3.x ejecutando un layout de tres paneles: git log a la izquierda, htop arriba a la derecha y un listado de archivos abajo a la derecha, con la barra de estado verde

tmux (~49k estrellas, C, ISC) es un binario de ~1,2 MB que está preinstalado o a un apt install tmux de distancia en cada servidor al que alguna vez te conectes. Un servidor en segundo plano posee tus sesiones, las ventanas actúan como pestañas, los paneles son divisiones dentro de las ventanas y la tecla de prefijo Ctrl+b se ha mantenido constante durante 18 años.

Qué llegó en tmux 3.7 y 3.8

tmux es conservador, no está muerto. Dos versiones recientes modernizaron varias aristas:

• Paneles flotantes (3.7, completado en 3.8): Ctrl+b * abre un panel flotante superpuesto sobre tu ventana actual sin alterar tu layout de divisiones, con atajos de mover/redimensionar bajo Ctrl+b g.
• Selector difuso integrado (3.8): Ctrl+b Tab abre un buscador difuso entre sesiones y ventanas, que sustituye a un script emergente externo con fzf solo para saltar entre sesiones.
• Temas claro/oscuro integrados (3.8): tmux ahora detecta el fondo de tu terminal y aplica una opción de tema incorporada sin configuración.
• Ayuda específica por modo y números de línea: pulsar Ctrl+h dentro del modo copia muestra solo los atajos del modo copia, y set -g copy-mode-line-numbers on añade números de línea para saltos de selección más rápidos.

Instalación y flujo diario

# Debian / Ubuntu
sudo apt update && sudo apt install -y tmux

# RHEL / AlmaLinux / Rocky / Fedora
sudo dnf install -y tmux

brew install tmux
tmux -V   # prints tmux 3.8

# Enable mouse clicks, pane resizing, and wheel scroll
set -g mouse on

# Start window and pane numbering at 1 instead of 0
set -g base-index 1
setw -g pane-base-index 1
set -g renumber-windows on

# 24-bit true color and image passthrough (Kitty/Sixel)
set -g default-terminal "tmux-256color"
set -as terminal-features ",*:RGB"
set -g allow-passthrough on

# Larger scrollback for build and agent logs
set -g history-limit 50000

El único comando que vale la pena convertir en alias en cada servidor es attach-or-create:

tmux new -A -s dev

Si la sesión dev ya existe, tmux new -A -s dev se conecta a ella; si no, la crea. Combínalo con tmux -CC attach -t dev en macOS si usas iTerm2 y quieres que las ventanas remotas de tmux se rendericen como pestañas nativas de macOS.

Dónde falla tmux en 2026

Para tmux, un Claude Code esperando la aprobación de un comando bash destructivo y un tail -f /var/log/syslog son idénticos: bytes en un panel. No hay estado semántico, ni bandeja de entrada entre sesiones, ni forma integrada de orquestar paneles desde un agente sin pegar scripts de shell con tmux send-keys y tmux capture-pane. La persistencia tras reinicio también requiere plugins de terceros (tmux-resurrect y tmux-continuum) vía TPM, y dos clientes conectados a la misma ventana siguen compartiendo una única posición de scroll salvo que crees sesiones agrupadas.

• Ideal para: servidores remotos que no administras, VPS mínimos, programación en pareja por SSH y cualquiera que quiera una configuración que seguirá funcionando sin cambios dentro de diez años.
• Olvídalo si: quieres controles de interfaz fáciles de descubrir o necesitas supervisar cinco agentes de codificación IA a la vez.

Mi guía básica de tmux recorre la instalación, las sesiones, las ventanas, los paneles, los plugins TPM y la resolución de desajustes de versión de protocolo tras las actualizaciones.

2. Zellij: el multiplexor moderno y amigable

Zellij 0.45.1 con tres paneles (git log a la izquierda, htop arriba a la derecha, listado de archivos abajo a la derecha) más sus características barras de pistas de teclas en la parte superior e inferior de la pantalla

Zellij (~35.7k estrellas, Rust, MIT) es el aspecto que tiene un multiplexor de terminal clásico cuando se diseña desde cero en Rust. En lugar de esconder cada comando detrás de una tecla de prefijo invisible, Zellij dibuja una barra contextual de pistas de teclas que muestra las teclas exactas disponibles en tu modo actual (NORMAL, PANE, TAB, RESIZE, MOVE, SEARCH, SESSION o LOCK). Puedes ponerle Zellij a un desarrollador que nunca ha usado un multiplexor y estará dividiendo, flotando y apilando paneles en dos minutos.

Qué hace destacar a Zellij 0.45.1

• Sesiones anidadas de primera clase (0.45 / 0.45.1): ejecutar Zellij en local y conectarte por SSH a un servidor remoto que también ejecuta Zellij solía ser una pesadilla de atajos de teclado. En 0.45.1, las sesiones anidadas diferencian automáticamente las barras de estado y los atajos internos y externos por SSH sin reenvío manual de variables de entorno.
• Scroll por comando: en lugar de desplazarte línea a línea por 10.000 líneas de salida del compilador, puedes saltar directamente entre bloques de comandos del shell.
• Layouts KDL reproducibles y resurrección de sesiones: los layouts viven en archivos .kdl limpios. Cuando una máquina se reinicia o una sesión termina, Zellij serializa tu layout y los comandos de los paneles en disco; al reconectar se restaura el espacio de trabajo exacto y los comandos peligrosos quedan detrás de una barrera de seguridad de «Pulsa ENTER para ejecutar».
• Sistema de plugins WebAssembly: los plugins se compilan a wasm32-wasip1, lo que significa que puedes escribirlos en Rust, Go, Zig o C/C++ y ejecutarlos en un entorno aislado por capacidades en lugar de dar a scripts de shell acceso total a tu cuenta de usuario.
• Cliente de navegador integrado (zellij web): sirve tus sesiones de terminal por HTTP/HTTPS con tokens de acceso generados y tokens de espectador de solo lectura, lo que lo convierte en el único multiplexor clásico con un servidor web propio integrado en el binario principal.

Instalación, layout KDL y comandos diarios

# macOS or Linux (Homebrew)
brew install zellij

# Rust cargo (any platform)
cargo install --locked zellij

# Quick launch without installing (Linux/macOS)
bash <(curl -L https://zellij.dev/launch)

# Start or reattach
zellij -s work                        # new named session
zellij attach -c work                 # attach if exists, create if not
zellij attach -c monitor -- htop      # start session running htop directly
zellij web                            # start built-in browser server

layout {
    default_tab_template {
        pane size=1 borderless=true {
            plugin location="zellij:tab-bar"
        }
        children
        pane size=2 borderless=true {
            plugin location="zellij:status-bar"
        }
    }
    tab name="code" focus=true {
        pane split_direction="vertical" {
            pane name="editor" size="60%" command="nvim"
            pane split_direction="horizontal" size="40%" {
                pane name="agent" command="claude"
                pane name="tests"
            }
        }
    }
}

Lanza ese layout en cualquier parte con zellij --layout dev (o zellij -n dev para forzar una sesión nueva).

Dónde se queda corto Zellij

Zellij tiene el mismo punto ciego que tmux con los agentes IA: un panel que ejecuta Claude Code o Codex no es más que un buffer de texto ANSI. Puedes programar paneles con zellij action y zellij run, y los plugins WASM de la comunidad empiezan a experimentar con ayudantes de agentes, pero no hay detector de estado de agentes ni bandeja de aprobaciones integrados.

• Ideal para: desarrolladores que quieren un sustituto de tmux con todo incluido: paneles flotantes/apilados, layouts de proyecto en KDL y cliente web integrado.
• Olvídalo si: necesitas seguimiento del estado de agentes IA sin configuración entre máquinas locales y remotas.

3. Herdr: el plano de control de agentes IA

Herdr 0.9 con la barra lateral de espacios a la izquierda listando la sesión y los grupos de agentes, y tres paneles ejecutando git log, htop y un listado de archivos

Herdr (~44k estrellas, Rust, Apache-2.0) fue el primer multiplexor construido específicamente en torno al cuello de botella multiagente: cuando tienes ocho agentes de codificación corriendo en tres repositorios, ¿cuál está atascado esperando tu entrada ahora mismo?

Herdr se ejecuta dentro de tu emulador de terminal actual como un único binario Rust de ~11 MB (herdr). Un servidor de sesiones en segundo plano posee los PTY, de modo que las sesiones sobreviven a cortes de SSH y a la suspensión del portátil igual que en tmux, mientras que la TUI añade una barra lateral de espacios y agentes a la izquierda que resume en tiempo real los estados semánticos de cada panel: working, blocked, done, idle o unknown.

Cómo detecta y orquesta agentes Herdr

Herdr combina dos capas de detección listas para usar con más de 14 agentes de codificación (Claude Code, Codex, Copilot CLI, Cursor Agent, OpenCode, Gemini CLI, Pi, Amp, Droid, Grok CLI, Hermes Agent, Antigravity CLI, Kimi Code y QoderCLI):

1. Manifiestos de pantalla TOML sin configuración: Herdr inspecciona el árbol de procesos hijos y compara el buffer inferior en vivo de cada panel con reglas de pantalla por agente para detectar spinners, solicitudes de permiso y prompts inactivos sin tocar la configuración del agente.
2. Hooks de ciclo de vida (herdr integration): instalar la integración opcional conecta con el sistema de hooks nativo del agente (como los hooks SessionStart, PreToolUse y Stop de Claude Code) para un reporte de estado exacto y sin latencia.

Debajo de la TUI hay una API JSON por socket Unix (~/.config/herdr/herdr.sock) y una CLI que permiten a un agente líder crear paneles trabajadores, pasar prompts, leer la salida de terminales hermanos y bloquear hasta que un trabajador alcance done o blocked:

# Install Herdr on Linux or macOS
curl -fsSL https://herdr.dev/install.sh | sh    # or: brew install herdr

# Optional: install exact lifecycle hooks
herdr integration install claude
herdr integration install codex
herdr integration install copilot

# Orchestrate panes and agents from scripts or a lead agent
herdr pane list                                 # JSON list of panes and states
herdr pane split --direction right --focus      # split current pane
herdr agent start reviewer --kind claude        # launch tracked agent in pane
herdr pane run <pane-id> "cargo test"           # run command in target pane

Ventanas multimáquina y el ecosistema de clientes

Desde la v0.9, Herdr soporta ventanas multimáquina: herdr machine add user@vps o herdr --remote user@vps te permite ver paneles locales y sesiones remotas de VPS dentro de una única barra lateral, además de gestión integrada de worktrees de git y reanudación automática de conversaciones de agentes tras reiniciar una máquina.

Como Herdr trata cada interfaz como un simple cliente conectado a su socket, todo un ecosistema de terceros ha crecido a su alrededor:

• Control móvil: Moshi (iOS/Android con transporte Mosh y aprobaciones push en pantalla de bloqueo con moshi-hook) y Heeler.
• Clientes de navegador y escritorio: ColliePWA, devswha/herdr-web-ui, herdrm (macOS nativo), Herdr UI y Moshi Desktop.
• Marketplace de plugins: ~1.000 plugins indexados (herdr-plugin.toml), aunque los plugins se ejecutan sin sandbox con tu usuario del SO, así que nunca instales plugins del marketplace sin leer antes su código fuente.

Lee nuestro análisis completo de Herdr, la comparativa de los mejores clientes de Herdr y la guía de los mejores plugins de Herdr para configuraciones endurecidas de VPS y Tailscale.

• Ideal para: ejecutar de 3 a 15 agentes de codificación IA entre máquinas locales y VPS headless, con aprobaciones desde la pantalla de bloqueo del teléfono y un ecosistema probado.
• Olvídalo si: quieres paneles flotantes o layouts de gestor de ventanas en mosaico (el modelo de layout de Herdr se limita a splits, pestañas, espacios y zoom).

4. TuiOS: el gestor de ventanas en mosaico + la Inbox de agentes más profunda

TuiOS 0.11.1 con tres ventanas en mosaico (git log a la izquierda, htop arriba a la derecha, listado de archivos abajo a la derecha) más la barra dock superior y el rail de sesiones a la derecha listando sesiones, terminales y archivos

TuiOS (~5.4k estrellas, Go, MIT) significa Terminal UI Operating System, y es el nuevo multiplexor dentro del terminal más audaz del año. Construido sobre Bubble Tea v2 y Lipgloss v2 de Charm con un demonio en segundo plano, combina dos ideas que normalmente viven en herramientas separadas: un gestor de ventanas en mosaico estilo escritorio (layouts BSP, master-stack y de desplazamiento tipo niri, ventanas flotantes, picture-in-picture, 9 espacios de trabajo por sesión, barra dock superior/inferior con gráficos de CPU/RAM en vivo y un rail derecho de sesiones/archivos/agentes) y un motor de orquestación de agentes que llega incluso más lejos que el de Herdr.

La Inbox, la retención de prompts y el fan-out en worktrees

Donde Herdr te da una barra lateral de estado, TuiOS integra todo el flujo de trabajo humano-en-el-bucle en su demonio:

1. La Inbox unificada (Ctrl+b i o tuios list-attention): reúne todas las aprobaciones bloqueadas, preguntas (tuios ask-human), revisiones de plan (ExitPlanMode), errores y turnos terminados sin leer de todas las sesiones de tu máquina y de los hosts remotos enlazados.
   • Al activar [agents.approvals], TuiOS intercepta las solicitudes de permiso de una línea (PermissionRequest en Claude Code/Qwen, permission.asked en OpenCode/Kilo) y las retiene en la Inbox. Pulsa 1 (permitir una vez), 2 (siempre) o 3 (rechazar) directamente desde la Inbox sin cambiar de espacio de trabajo.
   • Los comandos que coinciden con reglas de riesgo (rm -rf, force pushes, curl | sh o escrituras fuera de la raíz del proyecto del panel) se marcan con una insignia risk y requieren una segunda pulsación de confirmación.
2. Respuestas en cola y correo humano verificado: si un agente está ocupado a mitad de turno, tuios queue -w worker "run the migration tests next" retiene tu prompt y lo escribe automáticamente en el momento en que el agente se detiene. Los agentes también pueden enviarse correo estructurado entre sí (tuios send-agent-message, tuios ask-agent) o a human, con etiquetado criptográfico "verified_human": true para que un agente no pueda suplantar una aprobación humana ante otro panel.
3. Fan-out en worktrees de git, verificación y revisión de diffs en línea: puedes hacer competir a varios agentes (incluso de modelos distintos) en la misma tarea dentro de worktrees de git aislados, ejecutar una suite de tests sobre todos ellos, revisar sus diffs con notas por línea y quedarte con el ganador:

# Install TuiOS (macOS / Linux)
brew install tuios
# or release script:
curl -fsSL https://raw.githubusercontent.com/Gaurav-Gosain/tuios/main/install.sh | bash

# Fan a prompt across 3 isolated git worktrees using Claude, Codex, and Gemini
tuios fan 3 --agent 'claude,codex --model o5,gemini' 'Add exponential backoff to the HTTP client.'

# Compare line changes and run your test suite across every attempt
tuios fan compare api-fan-add-exponential-backoff
tuios fan verify api-fan-add-exponential-backoff -- go test ./...

# Review an attempt's diff, attach line notes, and send them back to the agent
tuios review api-fan-add-exponential-backoff-2
tuios review note -s api-fan-add-exponential-backoff-2 client/retry.go:42 'log the attempt count here'
tuios review send -s api-fan-add-exponential-backoff-2

# Keep the winning worktree, squash-merge, or open a PR
tuios fan keep api-fan-add-exponential-backoff-2 --merge --squash

Compatibilidad con el socket de Herdr, servidor MCP y el shim de tmux

La decisión de ingeniería más inteligente de TuiOS es que se niega a aislarse de los ecosistemas existentes:

• Puente de socket y plugins de Herdr: cada panel de TuiOS exporta HERDR_SOCKET_PATH, HERDR_PANE_ID y HERDR_BIN_PATH. TuiOS responde de forma nativa a 77 de los 102 métodos de socket de Herdr y ejecuta los plugins de Herdr habilitados (terminal-browser, herdr-nvim, herdr-sidebar) tras un sistema explícito de concesión de capacidades por panel (read, write, respond, fan, admin).
• El shim de tmux (tuios tmux-shim): las herramientas que tienen llamadas a tmux grabadas en el código (sobre todo los equipos de agentes experimentales de Claude Code con CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 y fzf --tmux) funcionan dentro de TuiOS sin instalar tmux:

  tuios tmux-shim -- env CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude

  Cada compañero de equipo generado se abre como una ventana nativa de TuiOS con su propio estado en el rail y en la Inbox.
• Servidor MCP nativo (tuios mcp) y ACP headless: tuios mcp expone TuiOS por stdio a cualquier agente compatible con MCP, y tuios start-agent --protocol acp 'opencode acp' puede ejecutar agentes en modo headless sobre el Agent Client Protocol.
• Paneles remotos y móvil: incluye un servidor SSH integrado (tuios ssh --port 2222), ventanas remotas ejecutándose en otro host renderizadas dentro de tu sesión local (tuios new-window -s work deploy --host build), copias de archivos entre hosts verificadas con SHA-256 (tuios cp), tuios-web, emparejamiento de teléfono por QR (tuios pair) y notificaciones push de la Inbox vía ntfy/Pushover.

Dónde falla TuiOS

Su edad y su superficie. El primer commit llegó en septiembre de 2025, y en la v0.11.1 tiene una superficie de comandos enorme (tuios --help lista más de 90 subcomandos). Publica rápido, lo que significa cambios que rompen compatibilidad ocasionales entre versiones menores y una curva de aprendizaje más pronunciada si activas todas las funciones a la vez. (Puedes poner [agents] enabled = false en ~/.config/tuios/config.toml si solo quieres el multiplexor en mosaico.)

• Ideal para: usuarios avanzados que quieren mosaico de terminal estilo i3/Hyprland, fan-out multiagente en worktrees y una Inbox que gestiona aprobaciones de prompts y revisiones de diffs de forma nativa.
• Olvídalo si: quieres una herramienta mínima y de evolución lenta con una CLI pequeña.

5. Rex: el terminal que es el multiplexor

La app de macOS Rex con pestañas de sesión en la parte superior y paneles divididos ejecutando una revisión de código, un git diff y un juego

Rex es la respuesta de Mitchell Hashimoto (HashiCorp, Ghostty) a un problema que encontró mientras construía Ghostty: los terminales modernos con GPU como Ghostty, Kitty y Alacritty pueden analizar la E/S del terminal hasta 100 veces más rápido que los emuladores de terminal internos de tmux o screen. Poner un multiplexor tradicional delante de un terminal rápido ahoga todo el pipeline al ritmo del analizador del multiplexor.

Así que Rex invierte la arquitectura. No ejecutas rex dentro de otro terminal; Rex es la aplicación de terminal.

Cómo funciona el streaming de bytes en bruto de Rex

1. El servidor posee los PTY. Cuando un cliente Rex se conecta, el servidor pausa brevemente el procesamiento del PTY, envía una trama binaria compacta de saludo (dimensiones, cursor, estado actual de la pantalla) y desbloquea la entrada de inmediato.
2. Bytes PTY en bruto, no diffs de pantalla. En lugar de analizar la salida en una cuadrícula virtual compartida y enviar diferencias de pantalla, el servidor Rex hace tee de los flujos de bytes PTY en bruto a cada cliente conectado, igual que SSH. Cada cliente ejecuta su propio motor libghostty embebido y analiza a velocidad nativa.
3. Scrollback independiente por cliente. El historial se rellena en segundo plano (los fragmentos más recientes primero), y como cada cliente posee su propio viewport, dos personas conectadas a la misma sesión pueden subir el scroll e inspeccionar los logs de forma independiente sin arrancarse la pantalla mutuamente.

Inicios de sesión remotos de primera clase y automatización con Lua

Añadir una máquina remota desde la paleta de comandos de Rex no solo abre un túnel SSH dentro de un panel local; realiza un inicio de sesión real del SO en el servidor Rex remoto (la sesión aparece en who, carga tu shell de login, respeta los límites de PAM/usuario y se autentica con tus claves SSH existentes o con tu identidad de Tailscale, inspeccionable con rex whoami) con una respuesta inspirada en Mosh.

Cada terminal Rex obtiene automáticamente rex en el PATH más las variables de entorno REX_SESSION, REX_BLOCK y REX_SERVER:

rex ls                              # list sessions (supports --json)
rex session inspect                 # inspect current session details
rex split                           # split current block
rex send -s build -w 2 'make test'  # send command to window 2 of "build"
rex capture -b logs                 # print current screen of block "logs"
rex -S studio ls                    # list sessions on remote host "studio"

-- Keybindings (supports tmux-style prefix chords too)
rex.bind("cmd+d", "pane.split", { direction = "right" })
rex.bind("ctrl+b>c", "window.new")

-- Custom typed action runnable from palette, keybind, or `rex do`
rex.action{
  name  = "scratch",
  title = "Open Scratch Window",
  run   = function(ctx, args)
    rex.session.new_window{
      layout = rex.layout.block{
        flavor = "com.superlogical.terminal.shell",
      },
    }
  end,
}
rex.bind("shift+cmd+n", "scratch")

Dónde falla Rex

Primero, el alcance de plataformas: solo el cliente de macOS está en pruebas públicas ahora mismo (existen clientes de Linux, Windows, iOS y navegador internamente en Superlogical, pero aún no han llegado a testers externos). Segundo, el modelo de layout: como cada split es una conexión PTY independiente renderizada en un contenedor nativo (que es como Rex se adaptará limpiamente a iOS y web), no hay un árbol de paneles tmux anidado dentro de la ventana. Tercero, Rex es de código cerrado, aunque Superlogical promete que el cliente y el servidor Rex «es y será siempre gratuito», no requiere cuenta y es totalmente autoalojable.

Si estás en macOS y quieres un terminal basado en libghostty con una CLI de automatización ya disponible de forma general y sin lista de espera, echa un vistazo a cmux. Para el análisis completo de la ruta de datos y los códigos de salida de Rex, lee mi informe sobre Superlogical Rex.

• Ideal para: desarrolladores en macOS que quieren velocidad nativa de libghostty, sesiones locales/remotas persistentes y programación por Lua/CLI sin una envoltura TUI.
• Olvídalo si: necesitas clientes de escritorio para Linux o Windows hoy, o quieres supervisión integrada del estado de agentes IA.

6. Tern: el terminal que quiere todo tu flujo de trabajo

El espacio de trabajo de Tern: un panel Files consciente de git siguiendo el proyecto a la izquierda junto a un shell ejecutando git log

Tern (construido por Stencil, el equipo detrás de la CLI de agente de codificación omp) parte de la misma premisa que Rex (un demonio en segundo plano tern daemon posee las sesiones persistentes mientras las ventanas son vistas desechables) y la lleva al territorio del espacio de trabajo completo. Autodenominándose «un neoterminal para los cansados de Electron», Tern es una aplicación nativa en Rust (arranque en frío de ~150 ms hasta un prompt activo) donde un shell de terminal es solo un tipo de bloque.

Bloques nativos sobre el Tern Surface Protocol

En lugar de embeber Chromium, Tern renderiza herramientas estructuradas de forma nativa sobre su Tern Surface Protocol justo al lado de tus splits de shell (o desacopladas como ventanas picture-in-picture siempre encima):

• Bloque Git (⌥⌘G): grafo de commits con carriles de ramas/etiquetas, árbol de trabajo con cambios preparados y sin preparar con staging por línea y plegado de contexto, git peek, vista de stashes/worktrees/submódulos y generación de mensajes de commit con IA.
• Bloque de base de datos SQLite: explorador de esquema, cuadrícula de datos filtrable con editores de celda en línea (texto, JSON, hex, imagen), pestañas de consultas SQL con autocompletado y gráficos de resultados, y «Write Changes» por fases / revertir.
• Bloque de tablero Kanban (⌥⌘K): convierte un simple archivo TODO.md de tu repo en un tablero arrastrable de Todo/Doing/Done que tanto tú como tus agentes de codificación IA podéis leer y actualizar.
• Bloque de cuaderno Jupyter: ejecuta celdas de código y Markdown directamente contra tu kernel local de Python con un inspector de variables, sin necesidad de servidor Jupyter.
• Bloque de archivos, editor y medios (⌘O / tern open): editor de código con resaltado de sintaxis y diffs de git en el margen, conmutador de Markdown renderizado, visores de SVG/PDF/imágenes y vistas previas de vídeo en tira de fotogramas (EDITOR='tern open --wait' funciona para git commit).
• Bloques de navegador (⇧⌘B), administrador de tareas y lienzo: un bloque de navegador inspeccionable que los agentes pueden manejar y capturar, un árbol de procesos CPU/RAM/GPU y un lienzo de dibujo libre.

Bloques de agente omp nativos, acceso remoto por QUIC y control por CLI

Como Stencil construye omp, lanzar un bloque de agente renderiza una interfaz nativa con selector de modelo, conmutador de pensamiento, árbol de tareas de subagentes y un desglose del presupuesto de contexto de 1M de tokens (system prompt, herramientas, skills, mensajes), mientras encamina las alertas de finalización y los eventos de campana a la bandeja «Needs attention» de Tern. Los agentes CLI estándar (Claude Code, Codex, Devin) corren en paneles de terminal normales, y un plugin Luau para Herdr de la comunidad permite embeber paneles de Herdr dentro de Tern.

# Tern workspace & automation CLI
tern ls                              # list sessions, tabs, and panes
tern new | split | move | pip | dock # manipulate window layout from scripts
tern run 'make test'                 # execute command in a pane
tern send / capture / wait           # type into, read back, or block on panes
tern events --filter pane_spawned    # stream live daemon events
tern whoami --json                   # inspect user + host identity chain

# Remote hosts, browser client, and headless screenshot harness
tern remote serve                    # expose session daemon over QUIC
tern web serve                       # serve Wasm + WebGPU client in a browser tab
tern shot scenario.kdl               # render offscreen UI captures

A diferencia de Rex, Tern ya publica compilaciones para macOS, Linux, Windows y Android (emparejadas por código QR desde la paleta de hosts, con iOS a continuación), además de un cliente de navegador WebAssembly + WebGPU (tern web serve).

Dónde falla Tern

Tern es de código cerrado, actualmente en beta cerrada tras una lista de espera (la mía se aprobó en unos dos días), y Stencil aún no ha anunciado precios finales ni niveles comerciales. Para un recorrido completo por cada bloque, consulta mi análisis práctico del terminal Tern.

• Ideal para: desarrolladores que quieren sesiones persistidas por demonio, hosts remotos por QUIC y paneles nativos de git/SQLite/kanban/cuadernos sin la sobrecarga de Electron.
• Olvídalo si: solo adoptas herramientas de terminal de código abierto o quieres una utilidad Unix ligera que haga una sola cosa.

Orquestación de agentes de codificación IA comparada

Como los agentes de codificación IA son la razón principal por la que los desarrolladores están repensando su multiplexor en 2026, así se comparan las seis herramientas específicamente en flujos de trabajo con agentes:

Chuleta de atajos de teclado y vocabulario

Moverse entre estas seis herramientas es mucho más fácil cuando ves cómo se corresponden sus sustantivos y atajos por defecto:

SSH remoto, teléfonos y navegadores comparados

• Mejor para servidores que no son tuyos: tmux, y nada se le acerca. Ya está instalado en casi cualquier servidor de cliente, host de contenedores y máquina BSD.
• Mejor protocolo remoto de nueva generación: Rex (inicio de sesión real del sistema con respuesta tipo Mosh) y Tern (tern remote serve sobre QUIC hacia clientes de escritorio, navegador WebGPU y Android). TuiOS ocupa el tercer puesto con su capacidad de montar un único panel remoto de otro host dentro de tu espacio de trabajo local (tuios new-window --host build).
• Mejor experiencia en teléfono hoy: Herdr junto a Moshi (transporte Mosh por UDP + botones de aprobar/denegar en pantalla de bloqueo con moshi-hook) o Heeler, con TuiOS (QR tuios pair + notificaciones push de la Inbox vía ntfy/Pushover) y Tern (cliente Android) justo detrás.
• Mejor experiencia en navegador: Zellij (zellij web con autenticación integrada y tokens de solo lectura) y Tern (cliente WebGPU con tern web serve). tuios-web y las interfaces web comunitarias de Herdr (ColliePWA, herdr-web-ui) van genial sobre Tailscale.

¿Qué multiplexor de terminal deberías elegir realmente?

Combinaciones del mundo real (y la única regla de anidado)

No tienes que elegir solo una. Mi propio stack diario usa tres:

1. tmux en los servidores de producción que toco una vez al mes.
2. Herdr + Moshi en un VPS Hetzner siempre encendido donde viven las sesiones largas de Claude Code y Codex.
3. TuiOS (o Herdr dentro de Tern) cuando quiero fan-out de worktrees (tuios fan) o bloques nativos de git/SQLite en mi estación de trabajo.

El anidado funciona bien siempre que sigas una regla: mantén una única capa de multiplexor directamente encima de tus agentes de codificación IA. Ejecutar Herdr dentro de un panel de Tern funciona porque Tern renderiza la ventana exterior mientras Herdr posee directamente los PTY de los agentes. Poner tmux entre Herdr/TuiOS y tu agente de codificación rompe la detección automática del árbol de procesos (el multiplexor exterior ve tmux, no claude ni codex). Si una herramienta intenta crear paneles tmux por debajo de ti, ejecútala bajo tuios tmux-shim en lugar de anidar un servidor tmux real.

Preguntas frecuentes

Veredicto

No hay un único ganador porque la categoría se dividió en tres trabajos distintos:

1. Multiplexado clásico de shell: tmux sigue intocable en servidores remotos que no son tuyos, y Zellij es la mejor actualización moderna cuando quieres layouts KDL, paneles flotantes, sesiones SSH anidadas y pistas de teclas en pantalla sin pasarte un fin de semana escribiendo un archivo de configuración.
2. Multiplexado de agentes IA: Herdr es la elección más segura hoy para supervisar una flota de agentes de codificación entre máquinas locales y remotas, mientras que TuiOS es el aspirante más ambicioso con su gestor de ventanas en mosaico, Inbox unificada, revisión de diffs en línea, fan-out de worktrees y shims de compatibilidad con Herdr/tmux.
3. Aplicaciones de terminal de nueva generación: Rex y Tern demuestran que integrar la persistencia de sesiones y el acceso remoto en el propio emulador de terminal es más rápido y limpio que ejecutar una TUI dentro de otra TUI: Rex para los puristas de libghostty en macOS, Tern para desarrolladores que quieren git, SQLite, kanban y cuadernos justo al lado de su prompt.

Si tu día en el terminal es sobre todo shells y logs, instala tmux o Zellij y vuelve al trabajo. Si la mitad de tus paneles son agentes de codificación IA, cámbiate a un multiplexor que sepa que están ahí.