Goose: el agente de IA open source que puedes conectar a cualquier modelo

Actualmente hay muchos agentes de IA funcionando desde la terminal, otros desde una extensión de VS Code, y otros desde una aplicación de escritorio. Hoy vamos a ver Goose, un agente de IA enteramente open source que no está ligado a ningún modelo, lo que significa que puedes conectarle cualquier suscripción que ya tengas o incluso modelos corriendo localmente en tu máquina.

En este artículo vamos a ver:

• Qué características tiene y qué se puede hacer.
• Cómo instalarlo y configurarlo en Windows, Mac o Linux.
• Sus MCPs incluidos para controlar el navegador.
• El soporte de subagentes, skills y recipes.
• Cómo conectar MCPs externos como TestSprite.
• La aplicación de escritorio.

Si buscas un agente de IA completamente configurable, abierto, y donde puedes ver el código fuente entero, sigue leyendo.

¿Qué es Goose?

Goose es básicamente un agente open source al que puedes conectarle cualquier tipo de modelo inteligente. Aunque inicialmente nació como una extensión para editores basados en Visual Studio Code, hoy ya tiene mucho más:

• Aplicación de escritorio (macOS, Linux, Windows).
• Herramienta de consola (CLI).
• API para integrarlo en tus propios proyectos.
• Soporte para MCPs y Skills.
• Extensiones incluidas (Computer Controller, Memory, etc.).

Y como es open source, esto significa que si tienes un modelo corriendo en tu máquina con Ollama o servicios similares, puedes conectarlo a Goose. Lo mismo si pagas algún proveedor como OpenRouter, un modelo chino, o tu suscripción de ChatGPT Codex / Claude.

Recursos oficiales:

• 📖 Documentación: goose-docs.ai
• 💻 Código fuente en GitHub: github.com/aaif-goose/goose

Instalando Goose CLI

Vamos a empezar con la versión más común: Goose CLI (también llamado goose). Es una herramienta de consola que funciona en Mac, Linux y Windows.

En Mac o Linux

El comando es directo, copia y pega desde la documentación oficial:

curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash

En Windows

En Windows hay un detalle: existen varias formas de instalarlo dependiendo de la terminal. En la guía de instalación oficial, puedes elegir entre Git Bash / MSYS2 (para ejecutar comandos tipo Linux) o PowerShell.

Vamos con PowerShell. Buscas en la guía la sección "PowerShell Installation" y copias el comando:

irm https://github.com/block/goose/releases/download/stable/download_cli.ps1 | iex

Pegas el comando y le das enter. Esto descarga un script. Luego la documentación te dice que ejecutes ese script: copias el segundo comando, lo pegas, y listo.

Configurando un proveedor

Una vez instalado, se lanza la configuración inicial. Aquí te dice "Configure providers" y al elegir esa opción, te muestra los proveedores disponibles:

• Amazon Bedrock
• Azure
• ChatGPT (Codex)
• Claude Code
• Y muchos más

En este caso voy a usar mi suscripción de ChatGPT, así que escojo ChatGPT Codex. Se lanza una ventana de autenticación, me autentico, le doy en continuar y listo. Con eso ya autoricé a Goose para usar mi suscripción de ChatGPT.

Después te pregunta qué modelo quieres usar (GPT-5.1, GPT-5, o listar uno que no esté ahí). Elijo GPT-5.1, y luego el nivel de esfuerzo: medium, que es el recomendado.

Ya tenemos a Goose instalado. Ahora desde cualquier carpeta puedo ejecutar:

goose

Te pregunta si quieres compartir datos de forma anónima (la telemetría). Le digo que no por ahora.

Tip: puedes presionar Ctrl + L para limpiar la pantalla.

Primer test: creando una app desde cero

Vamos a probarlo con una tarea real:

"Crea un administrador de gastos personales usando JavaScript vanilla y localStorage."

Apenas envías el mensaje, ves cómo Goose empieza a planificar. Crea como una lista de TODOs internos: primero entiende la tarea, luego revisa dónde estamos, y a partir de ahí va mostrando todo lo que va encontrando a medida que ejecuta comandos.

Es bastante rápido, sobre todo considerando que está usando un proveedor externo (mi suscripción de ChatGPT).

Después de un rato me dice "Listo, he creado el proyecto" e incluye formularios, validaciones y demás. Le digo "ejecútalo" y arranca el servidor. Aunque falla la primera vez, lo vuelve a intentar y termina abriendo la URL en el navegador.

Ahí está nuestra app: una forma de registrar gastos que se guarda en localStorage. Si refresco la página, los datos se mantienen.

Algo bonito de Goose: te muestra cuánto contexto vas gastando y cuál es el límite. En este caso me permite hasta 1 millón de tokens y solo llevo 1% usado.

Extensiones built-in: Computer Controller

Supongamos que ahora quiero que Goose mismo pruebe la app que creó. Para eso podemos configurar una extensión.

Cancelo la consola y ejecuto:

goose configure

Aquí me dice "configurar proveedores", "custom providers", pero la opción que me interesa es "Add extension". Le doy enter.

Te pregunta qué tipo de extensión quieres añadir:

• Extensiones de línea de comandos.
• Extensiones que funcionan en remoto.
• Built-in extensions (preconstruidas).

Vamos con built-in. Aparecen varias opciones: memory (para guardar conversaciones en archivos) y la que nos interesa ahora: computer controller, que tiene controles para web scraping y permite controlar el navegador.

Le doy enter, me pide un timeout (le pongo 300 segundos) y listo.

Reanudando la sesión

Para volver a la sesión que ya tenía abierta, ejecuto:

goose session -r

Esto reanuda la sesión anterior, y de hecho ahí veo el 1% de contexto que ya había usado.

Le digo:

"Usando computer controller, abre la aplicación e inserta algunos datos de prueba desde la UI."

Goose lanza una tarea: "tengo que abrir la aplicación usando computer controller", llama al script de automatización, y abre el navegador. Lo interesante es que no abre un navegador aparte: controla el que tienes abierto normalmente. Y ahí mismo empieza a llenar los datos.

Importante: maneja esto con cuidado. La IA puede interpretar muchas cosas, así que en proyectos sensibles ten ojo con qué le pides al Computer Controller.

Técnicamente, este Computer Controller es un MCP que ya viene preincluido en Goose, desarrollado por el mismo equipo de Block en Rust. No tienes que instalar nada extra. Si te da curiosidad ver cómo está hecho por dentro, el código fuente está disponible en el repo: crates/goose-mcp/src.

Skills en Goose

Goose también soporta skills, que son ya un estándar para cualquier herramienta de IA. Llamarlos es bastante fácil: solo escribes /skills en la sesión.

Si limpias y escribes:

/skills

Verás todos los skills disponibles en tu computador.

Instalando un skill desde skills.com

Para encontrar skills hay una web muy popular llamada skills.com (o el ecosistema de skills compartidos). Por ejemplo, vamos a usar uno llamado Web Design Guidelines de Vercel (los mismos creadores de Next.js).

Copias el comando que te dan en la web, lo pegas en la terminal dentro de tu proyecto, y se lanza un asistente que te pregunta:

• ¿Para qué agente quieres instalar el skill? (Claude Code, OpenCode, Goose, etc.)
• ¿A nivel de proyecto o global?
• ¿Quieres usar symlink?

Eliges Goose con la barra espaciadora, le das enter, lo seleccionas a nivel de proyecto, le dices symlink: yes, y listo. Ahora tienes una carpeta .skills/ con el skill instalado.

Si ahora ejecutas goose y escribes /skills, aparece Web Design Guidelines en la lista.

Para usarlo:

"Usando Web Design Guidelines, mejora la UI."

Goose carga el skill y empieza a alterar el código base.

Otro ejemplo: Frontend Design (de Anthropic)

Otro skill bastante usado es Frontend Design, creado por Anthropic. Mismo proceso: copias el comando, lo pegas, eliges Goose, y se instala.

goose
> Mejora el diseño usando frontend design skill. Cambio el diseño completamente. Es una aplicación, no un landing.

Esa última instrucción ("es una aplicación, no un landing") es importante porque ese skill está pensado para landing pages. Si tu proyecto es algo distinto, díselo explícitamente.

Subagentes en paralelo

Algo genial que también hace Goose es lanzar múltiples subagentes simultáneamente.

Por ejemplo, en este proyecto solo tengo una página en JavaScript. Vamos a pedirle dos cosas a la vez:

"Lanza dos subagentes, uno para documentar en una carpeta docs/ y otro para crear una UI de login y registro de usuarios."

Goose responde: "He lanzado dos subagentes en paralelo." Y empiezan a trabajar simultáneamente.

Algo bueno: los subagentes se pueden invocar simplemente con lenguaje natural. Funcionan de dos formas:

• Secuencial: primero analiza el código y luego genera la documentación.
• Paralelo: como en el ejemplo anterior, donde le pedimos crear las dos cosas al mismo tiempo.

En unos 25 segundos tengo:

• Una carpeta docs/ con la documentación generada.
• Una nueva interfaz de login/register.

Recipes: configurando comportamiento avanzado

Goose también permite crear algo llamado Recipes: instrucciones que combinan ejecución de extensiones y comportamiento de subagentes.

Es decir, puedes definir cómo se va a comportar un subagente, qué extensiones puede usar, y empaquetarlo como un workflow reusable. Por ejemplo, puedes crear un Code Reviewer con sus propias instrucciones, título, actividades específicas, y las extensiones que tiene disponibles.

Las recipes son archivos versionables que puedes commitear a Git y compartir con tu equipo, lo que es ideal para automatizar tareas repetitivas.

La extensión de Memory

Otra extensión incluida es memory, que permite que Goose funcione también como un asistente personal (similar a proyectos como OpenClaw o Hermes).

Para activarla:

goose configure
> Add extension
> Built-in extension
> memory
> timeout: 300

Listo. Ahora si escribo:

"My nickname is fazt. Recuérdalo."

Goose me dice: "Sí puedo recordarlo, pero para guardar la memoria necesito tu confirmación. ¿Quieres que guarde tu apodo?"

Le digo que sí, me pregunta si lo guardo en local (dentro del proyecto) o global, elijo local. Eso crea una carpeta .goose/ con un archivo de texto que es la memoria.

Si entro en otra sesión y le pregunto "¿cuál es mi nickname?", Goose carga el archivo y me responde correctamente.

Añadiendo otro proveedor (Minimax)

Si quieres añadir otro proveedor además del que configuraste inicialmente, vuelves a goose configure y eliges "Configure providers".

Por ejemplo, vamos a añadir Minimax, que es un modelo de un proveedor chino, mucho más barato y que trata de competir con Claude Opus. Copias tu API key desde su dashboard, la pegas, y eliges la versión del modelo que quieres usar.

Ahora si lanzo Goose, me dice que estoy usando Minimax. Le doy una tarea concreta:

"Migra este código de JS a React con TypeScript."

Y empieza a hacer la migración. Después de un minuto está terminado y la aplicación sigue funcionando idénticamente, solo que ahora con otro modelo distinto.

Esto es lo poderoso de Goose: un mismo workflow, diferentes modelos según el caso de uso o presupuesto.

Instalando MCPs externos

Algo importante que debemos saber: lo que Goose llama "extensiones" no es más que MCPs. Esto significa que también puedes instalar MCPs externos: el de Figma, Context7, o cualquier otro.

Cuando entras en goose configure > Add extension, ves tres tipos:

• Built-in: las extensiones preconstruidas que ya vienen.
• Command line: MCPs que se instalan desde consola con un comando.
• Remote / URL: MCPs que se conectan vía URL.

Ejemplo: instalando TestSprite

Vamos a instalar TestSprite, una plataforma que ofrece un MCP para testear aplicaciones automáticamente. No solo prueba la app de forma visual (haciendo clic por todos lados), sino que también escribe tests en código.

Te creas una cuenta gratis en testsprite.com, entras en "Create test", eliges local (para testear en tu máquina), y eliges "Other IDEs" donde te dan el comando npx para instalarlo.

Volvemos a Goose:

goose configure
> Add extension
> Command line extension

Te pide:

• Nombre: testsprite
• Comando: npx
• Argumentos: -y (para auto-instalar) y el nombre del paquete que te dio TestSprite.
• Timeout: 300
• Descripción: "Extensión para hacer testing automatizado con IA"
• Variable de entorno: sí (porque es un servicio que requiere API key).

Vas al dashboard de TestSprite, creas una nueva API key llamada por ejemplo "goose", la copias, la pegas como variable de entorno y le das un nombre (API_KEY por ejemplo). Listo.

Ejecutando tests con TestSprite

Lanzas otra sesión de Goose en paralelo (puedes tener varias abiertas):

goose
> Ayúdame a hacer testing de este proyecto usando testsprite.

Te abre una ventana donde tienes que indicar:

• Qué vas a testear: el frontend, el código base.
• Usuario de prueba (opcional).
• Dónde está la aplicación: por ejemplo, localhost:5173.
• PRD (Product Requirements Document): un archivo que explica de qué se trata la app y hacia dónde quiere llegar.

Generando el PRD con Goose

El PRD es importante porque ayuda a la IA a entender el contexto. Si el proyecto está a medias, le permite continuar implementando las features que faltan.

Aquí está lo bonito: puedes generar el PRD con Goose mismo:

goose
> Analiza todo el proyecto y crea un PRD.

Después de un par de minutos tienes un archivo PRD generado. Lo cargas en TestSprite, le das continuar, y la herramienta empieza a ejecutar los tests uno tras otro.

En este ejemplo me creó 13 tests: comprobar que el login funcione, el registro, el flujo del dashboard, etc. Cada test tiene una previsualización en video donde ves los pasos exactos que ejecutó.

Y lo mejor: si hay errores, TestSprite sugiere correcciones, y puedes pedirle a Goose que las aplique e itere de nuevo. Los archivos de test quedan en una carpeta testsprite/ dentro de tu proyecto.

La aplicación de escritorio

Para terminar, vamos a probar la aplicación de escritorio. En la documentación oficial, en "Install Goose", buscas Goose Desktop y descargas el ZIP para tu sistema operativo.

En Windows, descargas el ZIP, lo descomprimes, sacas la carpeta y abres goose.exe.

Lo bueno es que todos los chats que ya tenías desde la terminal aparecen aquí. Puedes abrir un chat nuevo, ubicarlo en la carpeta que quieras, y desde ahí preguntarle algo como "de qué se trata este proyecto".

Algo mucho más fácil en la versión desktop: cambiar entre modelos. Hay un selector visual donde puedes elegir entre Minimax, Claude, GPT, modelos locales, o cualquier otro proveedor que hayas configurado.

La interfaz de escritorio también te muestra:

• Lista visual de skills instalados.
• Lista de applications lanzables (incluso hay una demo de un reloj).
• Scheduler para programar tareas.
• Extensiones habilitables/deshabilitables visualmente.

Conclusión

En lo personal te sugiero usar la terminal. Es mucho más fácil de controlar desde ahí, pero la app de escritorio es totalmente utilizable y al final puedes intercambiar entre múltiples modelos sin fricción.

Lo más interesante de Goose:

• No estás casado con un solo proveedor: puedes alternar entre ChatGPT, Claude, Minimax, Ollama local, etc.
• MCPs y Skills funcionan de la mano: cualquier MCP del ecosistema (Figma, TestSprite, Context7, GitHub, etc.) puedes instalarlo.
• Subagentes en paralelo: para tareas que se pueden dividir, ahorras muchísimo tiempo.
• Recipes: para automatizar workflows que vas a repetir.
• Open source: puedes ver el código entero, contribuir, o incluso forkearlo.

Enlaces y recursos

• 🦢 Web oficial y documentación: goose-docs.ai
• 💻 Repositorio en GitHub: github.com/aaif-goose/goose
• 🔧 Código de los MCPs incluidos (Computer Controller, Memory, etc.): crates/goose-mcp/src

Si tienes alguna otra duda de cómo funciona o qué otras cosas puede hacer, déjamelo en los comentarios del video.

Nos vemos en un próximo artículo. 🚀