---
title: "Tern: el terminal nativo en Rust de Stencil es todo un espacio de trabajo de desarrollo"
description: "Prueba a fondo de Tern, el terminal en Rust de Stencil en beta cerrada: sesiones persistentes en un daemon, bloques nativos para git, SQLite, Jupyter y kanban, hosts remotos y agentes omp integrados."
date: 2026-10-20
categories: ["tools"]
tags: ["tern","stencil","terminal"]
---
import YouTubeEmbed from "@components/widgets/YouTubeEmbed.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
import Button from "@components/widgets/Button.astro";
Tern es el nuevo terminal de [Stencil](https://stencil.so/tern), el equipo detrás del CLI de agentes [omp](https://omp.sh/). 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
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.
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.
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.
## 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.
### 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).
### 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.
### 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—.
### 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.
### 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—.
## Las sesiones sobreviven a la ventana — y viajan
La historia de la persistencia es la misma promesa que hace [Herdr](/es/herdr-multiplexor-agentes/), 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`—.
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](/es/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
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](https://docs.stencil.so/tern/) documentado, y una lista comunitaria en [awesome-tern](https://github.com/theblazehen/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](/es/mejores-clientes-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:
```sh
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](/es/superlogical-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 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
| | Tern | Herdr | Rex | tmux |
|---|---|---|---|---|
| Qué es | Terminal + app de espacio de trabajo | Multiplexor de agentes dentro de tu terminal | Terminal + multiplexor | Multiplexor dentro de tu terminal |
| Persistencia | Sesiones en el daemon | Servidor de sesiones | PTYs en el servidor | Servidor (detach/attach) |
| Historia remota | `tern remote serve` (QUIC), clientes web + móvil | Conexión SSH / cliente ligero | Remoting integrado, login real | SSH, luego attach |
| Agentes IA | Bloque nativo de omp + cualquier CLI | Barra lateral de estado + API de socket | Nada específico | Nada |
| Superficie extra | Bloques git/SQLite/Jupyter/kanban/navegador | Marketplace de plugins | Config en Lua + CLI `rex` | Enorme ecosistema de plugins |
| Se extiende con | Plugins Luau (local + remoto) | Plugins de la comunidad | Acciones Lua | Plugins de tmux |
| Plataformas | macOS, Windows, Linux, Android | Linux, macOS (Windows en beta) | macOS (otros por compilar) | Todas partes |
| Estado | Beta cerrada (lista de espera) | Código abierto, pre-1.0 | Pruebas públicas, macOS primero | En todas partes, maduro |
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](/es/terminal-ghostty/) cruzada con un IDE). [Herdr](/es/herdr-multiplexor-agentes/) es un plano de control para flotas de agentes que corre dentro de cualquier terminal (incluido Tern, vía plugin). [Rex](/es/superlogical-rex/) es la apuesta del creador de Ghostty por el terminal-como-multiplexor, solo para macOS por ahora. [tmux](/es/tmux-comandos-basicos/) 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
Está en beta cerrada sin precios anunciados. El acceso es a través de la lista de espera en stencil.so/tern con una cuenta de Stencil. En mi caso la aprobación tardó unos dos días.
Hoy hay builds para macOS, Windows, Linux y Android. Un cliente para iPhone está en camino, y `tern web serve` ya expone una sesión en una pestaña del navegador.
Son capas distintas. Tern es el terminal; tmux y Herdr corren dentro de uno (Herdr literalmente corre dentro de Tern mediante un plugin de la comunidad: la v0.4.0 añade dos bloques). Si tu problema es seguir el estado de muchos agentes, la barra lateral y la API de socket de Herdr aún hacen algo que Tern no hace. Consulta la guía básica de tmux para el flujo de trabajo del titular.
El CLI de agentes de Stencil —omp.sh— que funciona con modelos de múltiples proveedores (y puede aprovechar suscripciones como la de Codex). Los bloques de agente de Tern lo ejecutan de forma nativa, pero cualquier CLI de agente funciona en un panel normal.
El daemon de sesión es el producto: `tern remote serve` expone el daemon de un servidor vía QUIC, los hosts se añaden mediante un diálogo (dirección ssh o par de tailnet, usuario act-as, importación de `~/.ssh/config`), y cada host mantiene su propio estado de sesión. `tern web serve` da un cliente de navegador; el emparejamiento móvil es un escaneo de código QR.
Sí: el binario `tern` es también el CLI de control (`split`, `run`, `send`, `capture`, `wait`, `events`), `tern serve`/`ctl` manejan sesiones headless, y `tern shot` renderiza capturas de escenarios programados. Los agentes pueden manejarlo de la misma forma.
## 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](/es/herdr-multiplexor-agentes/) o sigues [Rex](/es/superlogical-rex/) desde la barrera, Tern merece los dos días de lista de espera.