Tern: el terminal nativo en Rust de Stencil es todo un espacio de trabajo de desarrollo

Tern es el nuevo terminal de Stencil, el equipo detrás del CLI de agentes omp. Tras unas horas usándolo entiendo el eslogan: «una neoterminal para los cansados de Electron». Es una app nativa en Rust donde el shell es solo un tipo de panel. Un cliente de git, un explorador de SQLite, notebooks de Jupyter, un tablero kanban sobre tu TODO.md, un editor de archivos, un gestor de tareas, incluso un navegador web son «bloques» que se dividen, se organizan en pestañas y flotan junto a tu prompt. Y como Stencil también hace omp, el agente de IA es un bloque de primera clase y no un plugin añadido a posteriori.

Tern está en beta cerrada. El acceso pasa por la lista de espera del sitio web (en mi caso tardó unos dos días). Hay builds para macOS, Windows, Linux y Android, y lo siguiente es un cliente para iPhone: la sesión que dejas en el escritorio puede seguirte al teléfono.

Qué es Tern en realidad

Dos ideas, una sobre otra:

1. Un daemon es dueño de los procesos; la ventana es solo un cliente. Cierra Tern, reinicia, vuelve a abrir: cada panel regresa a su directorio con su scrollback anterior, con un agente a mitad de conversación. tern remote serve expone el mismo daemon de sesión en un servidor vía QUIC, y tern web serve lo pone en una pestaña del navegador. Varios clientes pueden conectarse a un mismo daemon a la vez —app de escritorio, pestaña del navegador, teléfono— y lo que escribes en uno aparece en los demás.
2. Bloques, no solo paneles. Todo aquello para lo que normalmente harías ⌘-Tab a otra app existe como bloque nativo a un ⌘K de distancia: git, un explorador de base de datos, un notebook, un tablero kanban. Los programas describen su UI mediante el Tern Surface Protocol y Tern la dibuja de forma nativa: sin Chromium integrado, y Stencil afirma ~150 ms hasta un prompt operativo en un arranque en frío (151 ms p95, 153 ms para reabrir seis pestañas).

El vocabulario: una sesión contiene pestañas, una pestaña contiene paneles, un panel ejecuta un bloque —un shell, un agente o uno de los bloques de aplicación de abajo—. Las sesiones persisten en el daemon (tern daemon, que arranca automáticamente con cualquier ventana y puede instalarse como elemento de inicio de sesión), así que las ventanas son vistas desechables sobre un trabajo que no se detiene.

La parte de IA es omp ejecutándose como bloque nativo con su propio renderizador, en lugar de arte ANSI en una cuadrícula de terminal. Los bloques de agente tienen selectores de modelo, comandos de barra, skills y un inspector de contexto. Un panel de shell normal sigue pudiendo ejecutar cualquier otro CLI de agente —Codex, Devin, el que ya uses— porque al fin y al cabo sigue siendo un terminal.

La ventana: paneles, pestañas y disposiciones

Espacio de trabajo de Tern: el panel Files siguiendo el proyecto junto a un shell con la salida de git log

Las divisiones, pestañas y disposiciones se comportan como un multiplexor moderno: divide a la derecha o hacia abajo, amplía un panel para llenar la pestaña, equilibra el árbol, arrastra un panel a otra pestaña o sesión. El panel Files de la izquierda es una barra lateral del proyecto que sigue al bloque que tenga el foco —consciente de git, filtrable, y revela lo que el agente acaba de tocar—. Todo tiene atajo, y los atajos son reasignables.

Tres paneles de terminal divididos a la derecha y hacia abajo en Tern

Cualquier panel puede salirse como picture-in-picture: un pequeño marco siempre visible que puedes arrastrar, volver a anclar al árbol de divisiones, esconder contra el borde de la ventana o desplegar en abanico cuando tienes varios. Yo lo uso para mantener visible un agente en ejecución mientras trabajo debajo de él.

Un panel de terminal flotado como ventana picture-in-picture en Tern

La paleta de comandos (⌘K) es donde vive todo, con pestañas por ámbito: All, Commands, Files, Branches, Commits, Sessions, Hosts. Eso significa que abrir archivos de forma difusa, cambiar a una rama, saltar a un commit o cambiar de host son el mismo gesto.

También hay un sistema de notificaciones de verdad: una bandeja de «Needs attention» recoge campanadas, builds terminados, programas que han salido y agentes esperando entrada —cada entrada enlaza directamente al panel que la originó—. Cuando una ejecución larga de un agente termina, aterriza aquí en lugar de perderse silenciosamente en el scroll.

La bandeja de Tern recogiendo notificaciones de los paneles: agente esperando entrada, build completado

Los bloques

Archivos y el editor

tern open file (o ⌘O) abre código con resaltado de sintaxis y cambios de git en el margen, Markdown con alternancia entre renderizado y fuente, imágenes, SVG, PDF y medios en visores de verdad —los archivos de vídeo incluso tienen una vista previa en tira de fotogramas—. Guarda automáticamente, y EDITOR='tern open --wait' funciona para flujos tipo git commit porque el CLI se bloquea hasta que cierras el bloque.

AGENTS.md renderizado como documento dentro del bloque de archivos de Tern

Un archivo TypeScript abierto en el bloque de archivos de Tern con resaltado de sintaxis

Git (⌥⌘G)

Un cliente de git de verdad: carriles de ramas y etiquetas sobre un grafo de commits, una vista del árbol de trabajo con grupos staged/unstaged y contadores +/− por archivo, diffs con staging por línea y plegado/desplegado del contexto sin cambios, git peek en cualquier commit, una pestaña de refs que cubre branches/remotes/tags/stashes/worktrees/submodules, deshacer, y mensajes de commit asistidos por IA («Generate message», explicación con IA, staging con IA).

El bloque de git de Tern: árbol de trabajo con archivos sin staged junto al grafo de commits

Base de datos

SQLite portado desde DB Browser, como bloque. Cuatro áreas: Structure (árbol de esquema, crear/editar tablas e índices, attach, importar CSV/SQL), Browse (cuadrícula de datos con filtros por columna, ordenación, editores de celda en línea —texto, hex, JSON, XML, imagen—, New Record, vistas guardadas, exportar a CSV/JSON), Execute (pestañas SQL con autocompletado, cuadrícula de resultados, un log de SQL, incluso gráficos de resultados) y Pragmas. Los cambios se preparan como «Write Changes»/revert en lugar de confirmarse automáticamente, y las bases de datos en memoria están a un clic para trabajo temporal.

Ejecutando una consulta SQL en el bloque de base de datos de Tern con resultados en una cuadrícula

Explorando una tabla en el bloque de base de datos de Tern

Board (⌥⌘K)

Apúntalo a un TODO.md y se convierte en un kanban: carriles Todo/Doing/Done a partir de los encabezados, tarjetas a partir de las casillas, vistas de tablero y lista, arrastrar entre carriles, etiquetas y fechas en las tarjetas. Los agentes pueden leer y actualizar el archivo, lo que lo convierte en una lista de tareas compartida y barata entre tú y el modelo —usé exactamente esto para entregarle a un agente una cola de trabajo—.

Un TODO.md renderizado como tablero kanban en el bloque Board de Tern

Notebook

Jupyter sobre un kernel de Python normal —sin servidor que arrancar—. Celdas de código y Markdown, salidas reales, autocompletado, inspección, una hoja de variables, restart/interrupt. Mi celda de prueba se ejecutó con el Python 3.12 del sistema.

Un notebook de Jupyter ejecutando una celda de Python dentro de Tern

El resto de la estantería de bloques

• Canvas: un bloque de boceto libre (dibujo, formas, flechas, texto) junto a tu shell —útil para anotar capturas de pantalla para un vídeo—.
• Gestor de tareas: lista o árbol de procesos con medidores de CPU, memoria y GPU, filtrado, y salir/forzar salida por fila.
• Navegador (⇧⌘B): páginas reales en un bloque; la gracia es que omp puede manejarlo para inspeccionar lo que acaba de construir, incluidas capturas de página.
• Compartir pantalla: ver y controlar la pantalla de otra máquina, ajustada o a tamaño real, con un interruptor de control. Todavía no lo he probado a fondo.
• Notas: un bloque de texto rápido para apuntes.
• Carly: el asistente integrado de Stencil con modo de voz en tiempo real —tiene su propia página de ajustes, aún en fase temprana—.

El bloque gestor de tareas de Tern listando procesos ordenados por CPU

Un dibujo en el bloque Canvas de Tern

Las sesiones sobreviven a la ventana — y viajan

La historia de la persistencia es la misma promesa que hace Herdr, llevada más lejos: cierra la ventana a mitad de un build y nada se detiene, vuelve a abrir y estás exactamente donde lo dejaste. Maté la app con una sesión remota corriendo en un VPS —todo, incluida la conversación del agente, seguía ahí cuando regresé—.

El ámbito Hosts de la paleta de comandos es el conmutador: tu máquina, daemons de Tern remotos accesibles directamente o por una tailnet, y «Connect from mobile», que empareja un teléfono escaneando un código. Añadir un host es un diálogo, no un archivo de configuración: le das un host ssh, hostname o IP:port (o un endpoint id de Tern), indicas como qué usuario actuar, y Tern configura tern remote serve por ti —también puede sacar hosts directamente de ~/.ssh/config—.

El selector de Hosts en la paleta de comandos de Tern mostrando la máquina local y las opciones para añadir remotos

Añadiendo un host remoto en Tern: dirección ssh, usuario act-as, pares de la tailnet

Cada host mantiene su propio estado de sesión, así que saltar entre el portátil y un VPS no molesta a ninguno de los dos lados. tern whoami --json informa de la cadena de identidad del panel en el que estás (qué usuario, a través de qué host). Y tern web serve expone el daemon en una URL con token (http://127.0.0.1:8377/?token=…): el cliente de navegador es un build en wasm que renderiza con WebGPU, así que una pestaña del navegador es de verdad otro cliente, no un truco de escritorio remoto.

Es el mismo modelo que describí en el análisis de Superlogical Rex (el servidor es dueño de la sesión, los clientes se conectan), salvo que Tern lo trae hoy para Linux, Windows y Android, no solo para macOS.

Los agentes son nativos, no incrustados

Un bloque de agente omp dentro de Tern: selector de modelo, medidor de contexto de 1M, entrada de prompt

El bloque de agente es omp dibujado de forma nativa —el contraste que plantea el sitio es una sesión de omp como texto ANSI en una cuadrícula de 48×37 frente a la misma sesión renderizada por Tern—: un selector de modelo (el mío estaba en GLM-5.3-Flash), comandos de barra con skills, un interruptor de thinking, un panel de task-agents que muestra los subagentes que generó, y un inspector de contexto que desglosa la ventana. En mi sesión mostraba un presupuesto de 1M de tokens repartido entre el system prompt (~3k), herramientas, skills y mensajes —los servidores MCP también aparecerían ahí—. Recibes una notificación cuando una ejecución termina, lo que importa cuando saltas entre paneles.

Otros CLIs de agente se ejecutan como terminales ordinarios. Abrí Devin y Codex en paneles y conversé con normalidad; simplemente no reciben el chrome nativo de omp. Lo que lanza un «bloque de agente» es configurable (agent-command), así que tampoco estás atado a omp.

Luego está la capa de plugins: los plugins Luau añaden bloques, command lenses, comandos y estilos —localmente y en los hosts remotos a los que te conectas, lo cual es inusual—. Hay un gestor tern plugin (list|install|remove|link|reload), un SDK de plugins documentado, y una lista comunitaria en awesome-tern. Alguien ya escribió un plugin de Herdr —lo tengo instalado (v0.4.0, dos bloques), así que si estás metido en los clientes de Herdr y su barra lateral de estado de agentes, puedes anidar Herdr dentro de un panel de Tern y quedarte con lo mejor de ambos mundos.

Programable hasta las capturas de pantalla

tern hace también de CLI de control, y cada ventana conectada lo sigue en directo:

tern ls                              # sessions, tabs, panes
tern new | split | move | pip | dock # window surgery
tern run 'make test'                 # run a command in a pane
tern send / capture / wait           # type into, read back, block on panes
tern events --filter pane_spawned    # stream daemon events
tern whoami --json                   # identity chain of this pane
tern ssh user@host                   # ssh with Tern's terminfo installed
tern register                        # become the OS handler for its URL schemes

También hay una capa de desarrollo (tern help dev): tern serve ejecuta una sesión headless en un socket de control, tern ctl le envía comandos —dump, tree, pick, state, stats, layers, css reload, perf, trace, incluso record para filmar un documento en mp4—, y tern shot renderiza archivos de escenario offscreen. Todas las capturas de este artículo se produjeron con archivos de escenario de tern shot, el mismo harness con el que prueban la app.

Si te gustó la filosofía «todo es automatizable» del CLI rex en el artículo de Rex, este es el mismo instinto.

Personalización y velocidad

Cuatro disposiciones de ventana (rail, float, tiles, studio), toda la galería de temas de omp con vista previa en vivo, y tu propia configuración de powerlevel10k dibujada de forma nativa. Los estilos de prompt integrados (Tern, Lean, Classic, Rainbow, Pure, Starship, Spaceship, Robby Russell, Agnoster) no necesitan nada instalado. Las fuentes son independientes para terminal, UI y código; las decoraciones de ventana pueden ser las del sistema o los traffic lights/botones propios de Tern; la barra de estado y los encabezados de panel son conmutables. Ajustes es un único panel rápido con un campo de búsqueda y páginas para general, agentes, apariencia, terminal, bases de datos, notebooks, carly, teclado, git, plugins, sesiones, hosts y avanzado.

El panel de ajustes de Tern con la galería de temas

El rendimiento fue lo primero que noté: las operaciones de paneles, el visor de archivos y la UI de ajustes son inmediatos —sin el peaje de arranque de Electron, sin Chromium integrado en el bloque de navegador—. Incluso mis renders de capturas headless (dibujados por CPU en llvmpipe, sin GPU) produjeron fotogramas completos en pocos segundos.

La prueba de MiniMax M3.1

Durante el recorrido, apunté a un agente omp con el modelo gratuito MiniMax M3.1 Flash a un tablero lleno de tareas: «use the to-do and create my website». Construyó un sitio Astro completo (unas 2.000 líneas en 72 archivos), generó agentes de tareas, iteró sobre sus propios SVG mediocres tras ojearlos en el bloque de navegador, previsualizó el sitio en localhost y consiguió un 100 en rendimiento de Lighthouse. El modelo es genuinamente rápido, pero pensó mucho, el diseño era básico, y solo actualizó el archivo kanban al final en lugar de hacerlo sobre la marcha. La herramienta hizo su trabajo; el modelo es discreto. Un modelo gratuito dentro de un terminal tan capaz sigue siendo una buena combinación para trabajo de boilerplate.

Tern vs Herdr vs Rex vs tmux

Son herramientas distintas, sinceramente. Tern es un terminal que quiere absorber todo tu flujo de trabajo (lo más parecido en espíritu a la filosofía de UI nativa de Ghostty cruzada con un IDE). Herdr es un plano de control para flotas de agentes que corre dentro de cualquier terminal (incluido Tern, vía plugin). Rex es la apuesta del creador de Ghostty por el terminal-como-multiplexor, solo para macOS por ahora. tmux sigue siendo el titular que ya tienes en todas partes.

Asperezas a tener en cuenta

• Beta cerrada. Solo por lista de espera, sin precios anunciados, las funciones cambian rápido.
• Retraso en el panel Files. Los archivos creados por el agente no aparecían en la barra lateral sin un refresco en mi prueba —cosas de beta temprana—.
• La sincronización de Board depende del modelo. El archivo kanban solo refleja el progreso si el agente lo escribe; MiniMax lo hizo al final, no de forma continua.
• Ecosistema de plugins joven. El SDK está documentado y existe awesome-tern, pero tiene días de vida.
• Código cerrado. Los plugins Luau lo extienden, pero la app en sí no es abierta como Herdr o tmux.
• iOS aún no ha salido. Android llegó primero; el cliente de teléfono y compartir pantalla son las dos piezas que no pude verificar del todo.

FAQ

Veredicto

Tern es el lanzamiento de terminal más interesante que he probado este año. Las sesiones persistentes en el daemon, el modelo de bloques (git, SQLite, Jupyter, kanban como paneles nativos), los agentes omp de primera clase, los hosts remotos y un CLI programable suman algo más parecido a un terminal con forma de IDE que a un terminal con pestañas. Es una beta: la lista de espera, los tropiezos de refresco, el precio desconocido. Pero la base es rápida y genuinamente distinta. Si ya ejecutas agentes en Herdr o sigues Rex desde la barrera, Tern merece los dos días de lista de espera.