La interfaz subió de nivel

Empecé a trabajar con IA dentro del editor, como casi todo el mundo. Después me pasé a la terminal, con un editor ligero abierto al lado. Hoy, en mi propia máquina, sigo pasando la mayor parte del tiempo en la terminal: por costumbre, porque pesa menos y porque estoy pegado a la shell. Pero cada mes uso más la app: en el escritorio, y en el móvil cuando no estoy en la mesa. Gestiona mejor varios proyectos y conversaciones, y me deja mezclar en la misma barra lateral un chat normal, una sesión de código que corre en la nube y otra que corre en mi portátil.

Esa deriva no es solo mía. Cursor, OpenAI, Anthropic y GitHub se han pasado 2026 sacando el mismo tipo de producto: una ventana para gestionar agentes, no para editar ficheros. Puestos uno al lado del otro, los movimientos tienen un patrón. Cada salto subió lo que mira el humano. Primero el código, después el diff, después el resultado. El siguiente salto ya se ve, y en él el humano ni siquiera arranca el trabajo.

Cinco años en una imagen

Saltan a la vista dos cosas. La primera es que ninguna superficie ha desaparecido. El editor sigue ahí, la terminal sigue ahí, y las nuevas se han sumado encima. Lo que cambia es dónde pasas la mayor parte del día. La segunda es la densidad: casi todo lo que importa ha pasado en los últimos veinte meses.

El editor: el humano escribe, el modelo sugiere

GitHub Copilot abrió su technical preview en junio de 2021 y llegó a disponibilidad general un año después. La unidad de trabajo era una línea o una función: tú escribías y el modelo completaba. En 2023 llegó el chat dentro del editor (Copilot X en marzo, Copilot Chat en GA en diciembre), y a finales de 2024 Cursor añadió un agente a su Composer que elegía su propio contexto y usaba la terminal.

El agente ya hacía trabajo de varios pasos, pero el marco seguía siendo el fichero. El humano miraba código, porque el trabajo pasaba en el código.

La terminal: el agente necesita la máquina entera

Los agentes en terminal no nacieron en 2025. Aider y gpt-engineer ya estaban ahí a mediados de 2023. Lo que cambió en 2025 es que la terminal se convirtió en la vía principal: Claude Code salió en febrero como research preview, Codex CLI en abril, y Claude Code llegó a disponibilidad general en mayo.

La terminal ganó por lo que le da al agente, no por lo que le da a la persona. La shell es una interfaz universal a herramientas: tests, git, gestores de paquetes, cualquier CLI que tengas y cualquier script. Darle una terminal al agente es la forma más barata de darle todo. Y eso va de la mano de la autonomía creciente de los modelos: un agente capaz de lanzar cincuenta comandos por su cuenta necesita la máquina entera, no una caja de autocompletado.

Conviene separar la etapa de la terminal en dos formas de trabajar:

• Terminal más editor. La terminal da las órdenes y el editor queda abierto para leer el diff y llevar git. Sigues mirando código, pero como revisor, no como autor.
• Solo terminal. Gana peso la gestión de agentes, y los comandos de terminal pasan a ser el único punto manual del desarrollo. Puedes seguir abriendo un artefacto, un navegador para ver el resultado final o una extensión, pero el desarrollo en sí ocurre en la conversación. Es menos transparente: ves lo que el agente te cuenta, salvo que le pidas más.

En las dos, el humano mira el diff, y la unidad de trabajo es una tarea.

La nube: el portátil tiene techo

Los agentes en la nube llegaron antes que las apps que hoy los gestionan. Tres salieron en cinco días de mayo de 2025: los Background Agents de Cursor, Codex dentro de ChatGPT y el coding agent de Copilot, que toma una issue de GitHub y abre una pull request. Claude Code en la web llegó en octubre.

La comodidad es solo parte de la razón. La otra es la capacidad. Lanzar varios agentes a la vez, cada uno con su rama y su suite de tests, satura un portátil normal mucho antes de saturar tu atención. Los agentes en paralelo con worktrees funcionan, hasta que el cuello de botella pasa a ser la máquina.

La nube tiene su propio precio: el entorno tiene que ser reproducible. Si quieres que el agente remoto ejecute exactamente lo que se ejecuta en local, el repositorio tiene que ser dueño de su bootstrap: paquetes del sistema, bases de datos de test, secretos. No siempre compensa. A veces la tarea no necesita el entorno completo, y a veces es deseable dejar una fase en local, como la que toca datos que prefieres no mover o la comprobación final en tu propia máquina. Remote Control, de Anthropic, toma esa posición de forma explícita: la sesión sigue corriendo en tu ordenador y la manejas desde el móvil.

La app: el mismo trabajo, pero se ve

Aquí es donde pasó 2026. Claude Code llegó a la app de escritorio de Claude con Opus 4.5 en noviembre de 2025, ya con sesiones locales y remotas en paralelo. Luego, seguidos: la app de Codex en febrero, Cursor 3 en abril con una ventana para gestionar agentes en local, worktrees, nube y SSH, el rediseño del escritorio de Claude Code ese mismo mes, y la app de Copilot en junio.

La última es la que más dice. La empresa que inventó el asistente dentro del editor saca ahora una app independiente para lanzar agentes. Y Cursor 3 no eliminó el IDE: la ventana de agentes vive a su lado y puedes cambiar de una a otro. El editor no fue sustituido, dejó de ser el centro.

Visto desde dentro, lo que ofrece la app es menos espectacular de lo que suena, y ahí está justamente su valor:

• Un chat normal, pero para código. La conversación se parece a ChatGPT o a Claude, la interfaz que todo el mundo ya conoce, y debajo corre un agente con acceso a tu repositorio.
• Todo lo que rodea a la conversación, a mano. Diff, git, pull requests, artefactos, un panel de vista previa y un navegador embebido para ver el resultado. Sin cambiar de ventana.
• Lo mismo que haces en la terminal, pero más claro. Buena parte de la mejora es simplemente que se lee mejor: sesiones en una barra lateral, diffs con un visor de verdad, paneles que colocas a tu gusto.
• Varios dispositivos. Empiezas algo en la mesa y lo sigues desde el móvil. Con sesiones en la nube no es un truco: el trabajo nunca estuvo en tu portátil.

Y un cambio fácil de pasar por alto: en la misma barra lateral conviven conversaciones normales, sesiones de código remotas y sesiones locales. La app deja de ser un sitio para programar y pasa a ser el sitio donde trabajas.

El coste es el peso. Consume más recursos que una terminal, y es parte de por qué la terminal sigue siendo mi opción por defecto en mi propia máquina.

Lo que subió

Junta las etapas y aparece la tesis. No es que las interfaces se hayan vuelto más bonitas. Es que lo que el humano necesita ver ha subido un nivel cada vez.

La superficie se separa del harness

La consecuencia más importante no está en pantalla. El mismo agente corre ahora en la terminal, en el IDE, en la app de escritorio, en el navegador, desde el móvil, desde un ticket de Linear o Jira, o con un calendario. Lo que lo hace ese agente vive por debajo y lo comparten todas esas superficies: el harness.

Dos tendencias empujan en la misma dirección. Los modelos open source son cada vez más competentes y los frontier cada vez más baratos, así que elegir modelo se está convirtiendo en una decisión de enrutado más que de plataforma. Y el trabajo empieza a hacerse a escala: muchas sesiones, muchos repositorios, tareas largas. Llegados ahí, lo que distingue a los agentes de un equipo de los de otro no es el modelo ni la ventana, sino el harness.

Gestionar, no teclear

Cuando el humano deja de mirar cada paso, las preguntas cambian. Ya no son «cómo escribo esto», sino «qué puede hacer este agente, qué recibe, qué devuelve y cuándo para a preguntarme». Pesan más en el trabajo de horizonte largo, donde un agente corre durante horas y una mala decisión al principio se multiplica:

• Permisos. Qué puede tocar sin preguntar, qué no puede tocar nunca y en qué entorno. Desplegar, escribir en una base de datos compartida o enviar algo hacia fuera es otra categoría que editar un fichero.
• Entradas. Con qué contexto arranca: el ticket, la especificación, las instrucciones del repositorio, la memoria de sesiones anteriores. Un agente que arranca sin los hechos que cambian su juicio toma decisiones que no tomaría quien los conoce.
• Salidas. Qué cuenta como hecho y en qué forma vuelve: una pull request con evidencias, un informe con fuentes, tests que fallan antes y pasan después. El formato de la salida es lo que permite comprobar, a ti o al siguiente agente, sin reabrirlo todo.
• Escalado. Cuándo para y pregunta, y a quién. Un agente que nunca escala toma decisiones que no le tocan; uno que escala siempre te devuelve el trabajo.

Y la salida no siempre va a una persona. Cada vez más, la salida de un agente es la entrada de otro: un plan que ejecuta un implementador, un informe que revisa un revisor, una pull request que recoge un tester. Eso convierte el formato de la salida en un contrato entre agentes. Y añade algo que gestionar que una sola sesión nunca tuvo: la comunicación entre ellos. Qué le cuenta un agente a otro, si es verdad y quién se da cuenta cuando no lo es. Cuando leí los mensajes entre sesiones paralelas, el canal se usaba sobre todo para contarle a la otra sesión algo verdadero sobre su propio trabajo, y en el experimento una sesión pilló a otra publicando una release que no existía. Ese tráfico es parte de lo que necesita ver quien gestiona los agentes.

Para la superficie, eso se traduce en una lista corta. La pantalla para gestionar agentes tiene que enseñar el estado de cada uno, qué espera de ti, qué está bloqueado y por qué, qué se están pasando los agentes entre sí, y la evidencia de cada resultado a un clic. Todo lo demás es decoración. Es también la lista que fija cuántos agentes puede supervisar de verdad una persona, que es un límite humano, no técnico.

Agentes que van por detrás

El último paso es el que el humano no arranca. La cadena es esta: un cliente deja feedback, se crea un ticket, un agente lo desarrolla, y el humano supervisa el rendimiento de ese proceso a través de evals (también automatizadas), del feedback externo y del testing final. Nadie abre una sesión.

Suena a especulación, pero las piezas ya existen. Linear convirtió a los agentes en miembros del workspace en mayo de 2025, y tres meses después su integración con Cursor permitía reglas de triage que asignan issues al agente automáticamente. Copilot toma issues de Jira y Cursor también. Las Routines de Anthropic ejecutan un agente guardado en la nube con un calendario, al llamarlo por API o ante un evento de GitHub, sin ningún portátil encendido. La app de Copilot trae sus propias automatizaciones programadas. Casi todo sigue en preview, pero ya está lanzado.

En ese mundo, la interfaz para este tipo de trabajo deja de ser una ventana donde tecleas. Es un panel de métricas y una cola de lo que necesita tu criterio. El resultado llega a donde ya estás, que es el mismo movimiento que conté en Lleva tu aplicación al agente, visto desde el lado del desarrollador.

¿Y leer el código?

Hay casos en los que quieres estar cerca del código: un cambio delicado, una pieza de la que no te fías, una exploración en la que aún no sabes qué buscas. Eso no desaparece, pero se está convirtiendo en el caso límite, siempre que la evidencia se pueda extraer. Puedes pedirle al agente el fragmento exacto que cambió, abrirlo en el repositorio, pedir el test que lo demuestra. Lo que cuenta es verificar el resultado, no releer el camino, y una buena superficie pone esa evidencia a un clic.

Lo que viene

La terminal no se muere. Se convierte en sustrato: el sitio donde el agente ejecuta, y una superficie más para quien la prefiera. El editor tampoco se muere. Es lo que abres para mirar el código de cerca, y sigue siendo una forma de trabajar los ficheros que no son código y que producen los agentes, como reportes e informes, aunque ahí es una opción entre otras: un artefacto, un documento compartido, un drive. Lo que está pasando es que la interfaz se desacopla del agente. Elegirás la superficie según el momento y el dispositivo, mientras el harness de debajo sigue siendo el mismo.

Lo que distinguirá a un equipo, entonces, no es qué ventana usa. Es lo bien que ha definido qué pueden hacer sus agentes, qué reciben, qué devuelven y cuándo llaman a un humano. Eso es un problema de gestión, y es hacia donde va la interfaz: menos teclados y más paneles.

---

Fuentes de las fechas de la cronología: Copilot preview · Copilot GA · Copilot X · Copilot Chat GA · Cursor 0.43 · Cursor 2.0 · Aider releases · Claude Code preview · Codex CLI · Copilot CLI GA · Devin · Cursor Background Agents · Codex cloud · Copilot coding agent · Claude Code en la web · Claude Code en la app de escritorio · App de Codex · Cursor 3 · Rediseño del escritorio de Claude Code · App de Copilot GA · Linear for Agents · Cursor en Linear · Copilot para Jira · Routines · Cursor en Jira.