Tutorial de Goose, agente de IA: CLI, MCP, Ollama y Recipes

Goose es un agente de IA gratuito y de código abierto que se ejecuta en tu máquina, distribuido como una interfaz de línea de comandos (CLI), una aplicación de escritorio y una API. A diferencia de los asistentes de código simples, Goose va más allá de las sugerencias: ejecuta comandos de shell, edita archivos, ejecuta código y orquesta flujos de trabajo de varios pasos de forma autónoma. Goose se conecta a cualquier proveedor de Large Language Models (LLM), incluidos modelos que se ejecutan en local, y extiende sus capacidades a través de servidores Model Context Protocol (MCP).

Block presentó Goose en enero de 2025 como "codename goose", y desde entonces el proyecto ha evolucionado mucho. En diciembre de 2025, Block donó Goose a la Agentic AI Foundation (AAIF) de la Linux Foundation, junto con MCP de Anthropic y AGENTS.md de OpenAI, para que el futuro del proyecto lo decida la comunidad bajo una gobernanza neutral. En abril de 2026, el repositorio se trasladó a github.com/aaif-goose/goose y la documentación a goose-docs.ai. El proyecto ahora escribe su nombre en minúsculas ("goose"); los antiguos enlaces a block/goose todavía redirigen, pero las páginas de la documentación antigua no.

En este artículo, te muestro cómo instalar el CLI de Goose en Linux, macOS y Windows, cómo conectarlo a un modelo gratuito en la nube (Google Gemini) o a uno completamente local (Ollama), cómo ampliarlo con un servidor MCP y cómo automatizar tareas con recipes (recetas) y skills. Probé cada paso con Goose v1.54.0 en octubre de 2026.

Goose se distribuye en dos variantes que comparten la misma configuración: una aplicación de escritorio y una interfaz de línea de comandos (CLI). La aplicación de escritorio es la opción más cómoda si prefieres una ventana de chat, y puedes descargarla desde la guía de instalación (en macOS, brew install --cask block-goose). Yo prefiero el CLI porque es ligero, se puede automatizar con scripts y me permite interactuar con el agente sin salir del terminal, así que este artículo se centra en él.

En Linux y macOS, instala la última versión del CLI de Goose con:

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

Este script descarga el último binario de Goose para tu sistema operativo y arquitectura, lo instala en ~/.local/bin y lanza goose configure a continuación. Si prefieres configurar Goose más tarde, añade CONFIGURE=false delante de bash:

curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | CONFIGURE=false bash

Si ~/.local/bin no está en tu PATH, el script se ofrece a añadirlo al perfil de tu shell (con CONFIGURE=false, solo muestra un aviso y tendrás que añadirlo tú). Después, abre un terminal nuevo para que el shell encuentre el comando goose.

Para usuarios de macOS (y de Linux con Homebrew), Goose también está disponible a través de Homebrew:

brew install block-goose-cli

Una vez instalado, puedes actualizar Goose en cualquier momento ejecutando:

goose update

Si instalaste Goose con Homebrew, ejecuta brew upgrade block-goose-cli en su lugar para que Homebrew lleve el control de la versión.

En Windows, puedes ejecutar el mismo comando curl desde Git Bash o MSYS2. Desde PowerShell, descarga el script de instalación y ejecútalo:

Invoke-WebRequest -Uri "https://raw.githubusercontent.com/aaif-goose/goose/main/download_cli.ps1" -OutFile "download_cli.ps1"
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
.\download_cli.ps1

La línea Set-ExecutionPolicy permite ejecutar scripts solo en la ventana actual de PowerShell, ya que Windows los bloquea por defecto. El script de PowerShell instala Goose en .local\bin dentro de tu perfil de usuario (desde Git Bash, el script de bash usa %USERPROFILE%\goose); si el sistema no encuentra goose, añade a tu PATH el directorio que mostró el instalador. Si prefieres un entorno Linux, Goose también funciona dentro del Subsistema de Windows para Linux (WSL): sigue las instrucciones de Linux desde tu shell de WSL.

A continuación, configura Goose para usar un proveedor LLM. Goose soporta decenas de proveedores (la lista de goose configure tiene más de 80 entradas en la v1.54), agrupados en cuatro categorías principales:

• Proveedores basados en API: Anthropic (Claude), OpenAI, Google Gemini, xAI (Grok), Mistral AI, Groq, DeepSeek, OpenRouter y muchos más
• Plataformas en la nube: Amazon Bedrock, GCP Vertex AI, Azure OpenAI, Databricks, Snowflake
• Proveedores locales: Ollama, LM Studio y la inferencia local integrada de Goose (completamente gratis, se ejecuta en tu máquina)
• Tus suscripciones actuales: Claude Code, Codex y GitHub Copilot, que Goose controla a través del Agent Client Protocol (ACP) para que puedas reutilizar un plan que ya pagas

Solo necesitas un proveedor: empezaré con Gemini, la opción gratuita más rápida de configurar, y después te mostraré una alternativa completamente local con Ollama.

Elegí la API de Gemini, el proveedor LLM de Google, porque sigue ofreciendo una capa gratuita (a fecha de octubre de 2026) para sus modelos Flash y Flash-Lite, que manejan las llamadas a herramientas (tool calling) lo bastante bien como para hacer funcionar un agente. Eso sí, ten en cuenta dos matices. Google aplica los límites de la capa gratuita por proyecto y los cambia a menudo, así que comprueba tu cuota actual en Google AI Studio. En la capa gratuita, Google también puede usar tus prompts para mejorar sus productos, así que no le envíes código que no puedas compartir.

Para conectar Goose a Gemini, necesitas una cuenta de Google y una API key. Puedes generar esta clave en Google AI Studio:

Pulsa el botón "Create API key" para generar una nueva API key.

Utilizaremos esta API key para configurar Goose y conectarlo a Google Gemini. Si el script de instalación no ha iniciado ya el asistente, ejecuta el siguiente comando:

goose configure

La primera vez que lo ejecutas, el asistente de goose configure te pregunta si quieres compartir datos de uso anónimos y, después, cómo quieres configurar tu proveedor. Las dos primeras opciones (OpenRouter y Tetrate Agent Router) inician sesión a través del navegador; elige Manual Configuration en su lugar. La lista de proveedores es larga, así que selecciona Search all providers..., escribe Gemini y elige Google Gemini (API Key). Evita la entrada "Gemini" a secas, que inicia sesión con tu cuenta de Google y ahora está obsoleta.

Pega tu API key, selecciona el modelo predeterminado y, por último, elige el goose mode, que controla si Goose usa sus herramientas libremente o te pide aprobación primero. El modo predeterminado, Auto Mode, deja que Goose edite archivos y ejecute comandos sin preguntar; si vas a probar Goose en un proyecto real, elige Approve Mode o Smart Approve Mode (explico los modos en la primera sesión). Goose guarda la clave en el llavero (keyring) de tu sistema (Keychain en macOS, Credential Manager en Windows, Secret Service en Linux); cuando no hay ninguno, como en WSL o en un servidor, recurre a un archivo secrets.yaml en texto plano dentro de su directorio de configuración.

Si la configuración es correcta, verás un mensaje de confirmación. Si encuentras algún problema, ejecuta goose info --check para probar la conexión con el proveedor; goose info también muestra dónde guarda Goose su configuración y sus logs (~/.config/goose y ~/.local/state/goose/logs en Linux y macOS).

Si prefieres no enviar tu código a un proveedor en la nube, o no quieres preocuparte por los límites de uso, puedes ejecutar Goose con un modelo local a través de Ollama. Todo se queda en tu máquina, y el único límite es tu hardware.

Primero, instala Ollama y descarga un modelo que soporte llamadas a herramientas, por ejemplo, el pequeño modelo Qwen 3 que usé para este artículo (una descarga de 2,5 GB):

ollama pull qwen3:4b-instruct-2507-q4_K_M

Después ejecuta goose configure, elige Configure Providers (o Manual Configuration la primera vez), busca Ollama, acepta localhost como host, responde No a la configuración avanzada (advanced settings) y selecciona el modelo de la lista de modelos que has descargado:

Goose también puede ejecutar modelos sin Ollama: su inferencia local integrada descarga modelos GGUF y MLX desde Hugging Face. Ejecuta goose local-models search qwen para encontrar uno y goose local-models download para descargarlo.

Los modelos locales son gratuitos y privados, pero los modelos pequeños cometen errores que los grandes no cometen. qwen3:4b-instruct es un small language model de 4.000 millones de parámetros que funciona sin problemas en un portátil, y se desenvolvió bien editando archivos y ejecutando comandos de shell. Sin embargo, cuando le di la tarea de automatización del navegador que verás más adelante, llamó a las herramientas correctas y después se inventó tres de las cuatro URLs en lugar de leer los resultados. Si optas por un modelo local, usa el modelo más grande con soporte para llamadas a herramientas que pueda ejecutar tu máquina (por ejemplo, una variante mayor de Qwen 3.5 o gpt-oss:20b), y revisa sus respuestas. Al configurar Ollama, este pasa a ser tu proveedor predeterminado: el resto del artículo usa Gemini, así que ejecuta goose configure y vuelve a elegir Google Gemini antes de probar el ejemplo del navegador. Con MCP, incluso los modelos más pequeños pueden alcanzar un rendimiento de nivel experto en tareas especializadas, pero solo cuando las herramientas les dan el contexto adecuado.

Inicia una nueva sesión ejecutando el siguiente comando:

goose session

Este comando lanza una sesión de chat en el terminal donde puedes interactuar con el LLM.

En la imagen anterior, puedes ver una sesión de Goose ejecutándose en el terminal con el modelo local de Ollama. La cabecera muestra el proveedor, el modelo, el ID de la sesión y el directorio de trabajo, y la barra inferior indica qué parte de la ventana de contexto del modelo has usado. Le pedí a Goose que creara un script de Python que imprime la fecha de hoy y que lo ejecutara. Goose usó dos herramientas de su extensión integrada Developer: write para crear el archivo y shell para ejecutarlo.

Por defecto, Goose se ejecuta en modo Auto, lo que significa que edita archivos y ejecuta comandos sin preguntar. Es cómodo, pero si estás probando Goose en un proyecto real, cambia a un modo que pida aprobación primero, por ejemplo escribiendo /mode approve en la sesión:

• auto: Goose usa sus herramientas libremente (el modo predeterminado).
• approve: Goose pregunta antes de cada llamada a una herramienta.
• smart_approve: Goose solo pide confirmación para las acciones que considera arriesgadas. Ejecuta sin preguntar las herramientas que declaran la anotación MCP readOnlyHint como true, siempre pide confirmación para las que la declaran como false y deja que el modelo juzgue las que no la declaran.
• chat: Goose no usa ninguna herramienta.

Para cambiar el modo predeterminado de todas las sesiones, ejecuta goose configure y elige goose settings.

Goose también incluye otros comandos slash integrados que puedes usar durante una sesión:

• /help - Listar todos los comandos disponibles
• /model - Cambiar a otro modelo (o proveedor) sin salir de la sesión
• /skills - Listar las skills disponibles o cargar una por su nombre
• /prompts - Listar los prompts disponibles
• /compact - Compactar el historial de la conversación
• /clear - Limpiar la conversación
• /exit - Terminar la sesión

Para retomar más adelante el trabajo donde lo dejaste, ejecuta goose session -r, que reanuda tu sesión más reciente. Goose también lee automáticamente las instrucciones del proyecto de los archivos AGENTS.md y .goosehints, así que puedes describir las convenciones de tu proyecto una vez y reutilizarlas en cada sesión.

El ecosistema MCP ha crecido enormemente desde el lanzamiento inicial de Goose: solo el MCP Registry oficial recoge más de 40.000 servidores (octubre de 2026), que cubren herramientas de desarrollo, suites de productividad y servicios especializados.

Para demostrar la extensibilidad de Goose, configuremos el servidor MCP de Playwright de Microsoft. Este servidor permite la automatización del navegador utilizando el árbol de accesibilidad de Playwright, lo que lo hace rápido y fácil de usar para los LLM, sin necesidad de modelos de visión. Puedes configurarlo a través de la línea de comandos o editando tu archivo config.yaml. Para este ejemplo, usaremos la línea de comandos:

goose configure

El CLI te mostrará:

This will update your existing config files
  if you prefer, you can edit them directly at /home/user/.config/goose

┌   goose-configure
│
◆  What would you like to configure?
│  ○ Configure Providers (Change provider or update credentials)
│  ○ Custom Providers
│  ● Add Extension (Connect to a new extension)
│  ○ Toggle Extensions
│  ○ Remove Extension
│  ○ goose settings
└

Selecciona Add Extension, elige Command-line Extension e introduce los siguientes datos para el servidor MCP de Playwright:

┌   goose-configure
│
◇  What would you like to configure?
│  Add Extension
│
◇  What type of extension would you like to add?
│  Command-line Extension
│
◇  What would you like to call this extension?
│  playwright
│
◇  What command should be run?
│  npx @playwright/mcp@latest
│
◇  Please set the timeout for this tool (in secs):
│  300
│
◇  Enter a description for this extension:
│  Playwright
│
◇  Would you like to add environment variables?
│  No
│
└  Added playwright extension
└  Configuration saved successfully to /home/user/.config/goose/config.yaml

El asistente guarda la extensión en tu archivo config.yaml (ejecuta goose info para encontrarlo en Windows), así que también puedes añadirla a mano:

extensions:
  playwright:
    enabled: true
    type: stdio
    name: playwright
    description: Playwright
    cmd: npx
    args:
    - '@playwright/mcp@latest'
    timeout: 300

Para probar un servidor MCP en una sola sesión sin guardarlo, pásalo en la línea de comandos: goose session --with-extension "playwright:npx @playwright/mcp@latest".

Para demostrar las capacidades de Goose con el servidor MCP de Playwright, asegúrate de que tu proveedor es Gemini (u otro modelo en la nube capaz), inicia una nueva goose session para que Goose cargue la extensión y escribe el siguiente prompt:

Open a new browser window and navigate to https://blog.marcnuri.com, evaluate the links to find the author's LinkedIn, Bluesky, GitHub, and Twitter URLs

Goose abre una ventana del navegador, navega al sitio web y analiza el árbol de accesibilidad de la página. Luego extrae las URLs de LinkedIn, Bluesky, GitHub y Twitter del autor y las muestra.

En la imagen anterior, puedes ver la sesión de Goose con el servidor MCP de Playwright ejecutándose en el terminal, esta vez con Gemini como proveedor. Hice esta captura con una versión anterior de Goose, así que la cabecera de la sesión es diferente, pero el flujo es el mismo.

Después de enviar el prompt, Goose ejecutó estos pasos:

1. Goose envía mi prompt y las herramientas disponibles al LLM.
2. El LLM responde con acciones de Playwright, y Goose las ejecuta:
   • Abre una ventana del navegador.
   • Navega al sitio web.
   • Escanea el snapshot de accesibilidad de la página buscando enlaces de redes sociales.
3. Goose envía los resultados al LLM para su interpretación.
4. Goose muestra la respuesta final.

En este caso, interactuó con un único servidor MCP, pero puedes añadir varios servidores para ampliar aún más las capacidades de Goose.

En la aplicación de escritorio, Goose también soporta MCP Apps (una funcionalidad experimental), que permiten a las extensiones mostrar interfaces de usuario interactivas, como formularios, visualizaciones de datos y asistentes de configuración, en lugar de respuestas solo de texto.

Además de los servidores MCP, Goose soporta Recipes (recetas), una forma de empaquetar y compartir flujos de trabajo de IA reutilizables. Una recipe es un archivo YAML que agrupa instrucciones, un prompt, las extensiones necesarias, parámetros e incluso lógica de reintento en una configuración que puedes compartir.

Aquí tienes una recipe sencilla que genera un informe de estado semanal:

version: "1.0.0"
title: Weekly Status Report
description: Generate a summary of work completed this week
instructions: |
  Analyze the git history and open issues to create a brief status report.
  Focus on commits from the past 7 days.
prompt: Summarize what I accomplished this week.
extensions:
  - type: builtin
    name: developer

Las instructions le indican al agente cómo comportarse, mientras que el prompt es la tarea que ejecuta cuando lanzas la recipe desde el CLI. Cada entrada de extensions es un objeto con un type y un name, no solo el nombre de la extensión. Puedes validar una recipe antes de ejecutarla:

goose recipe validate weekly-report.yaml

Ejecuta una recipe desde el CLI:

goose run --recipe weekly-report.yaml

Las recipes pueden incluir parámetros para entradas dinámicas (--params key=value), lógica de reintento para validación automatizada y sub-recipes para componer flujos de trabajo complejos. También puedes programar recipes para que se ejecuten automáticamente usando expresiones cron:

goose schedule add --schedule-id daily-report --cron "0 9 * * *" --recipe-source ./recipes/daily-report.yaml

El programador de tareas está integrado en Goose, no usa el cron de tu sistema, así que una tarea programada solo se lanza mientras haya un proceso de Goose en ejecución continua: la aplicación de escritorio, o goose serve --enable-scheduler en una máquina sin ella. Las ejecuciones programadas siempre usan el modo auto, sea cual sea tu modo predeterminado, así que ten cuidado con las recipes que leen texto escrito por otras personas, como issues o páginas web.

La comunidad de Goose comparte recipes listas para usar en el Recipes Cookbook, y puedes explorar servidores MCP que funcionan con Goose en el directorio de extensiones.

Las recipes son flujos de trabajo que lanzas de forma explícita. Las skills son la otra mitad de la historia: instrucciones reutilizables que Goose carga por su cuenta cuando tu petición encaja con ellas. Una skill es un directorio con un archivo SKILL.md que tiene un name, una description y las instrucciones:

---
name: release-notes
description: Draft release notes from the commits since the last tag
---

List the commits since the latest git tag, group them by type, and draft release notes in Markdown.

Goose descubre skills en ~/.agents/skills/ (globales) y .agents/skills/ (por proyecto), y también lee los directorios .claude/skills/ que usa Claude Code. Cuando ejecuté goose skills list en el repositorio de este blog, listó mi skill global y, junto a ella, las skills de Claude Code que uso para mantener el blog, sin ninguna configuración adicional. En una sesión, /skills las lista, y /skills release-notes carga una por su nombre. Si quieres ver hasta dónde pueden llegar las skills, echa un vistazo a Superpowers, un framework de skills para agentes de programación.

Una de mis características favoritas de Goose es su capacidad para conectarse a diferentes proveedores LLM. Hasta ahora hemos usado Google Gemini y un modelo local de Ollama, pero es posible que quieras cambiar a otro proveedor por diversas razones.

Probemos a conectarnos a Groq, un proveedor LLM conocido por su velocidad. Groq ejecuta modelos open-weight, como gpt-oss de OpenAI, en su propio hardware de inferencia Language Processing Unit (LPU), lo que lo hace ideal para tareas de IA en tiempo real.

Groq también ofrece un plan gratuito, pero su límite de tokens por minuto (8.000 para gpt-oss-120b a fecha de octubre de 2026) suele ser demasiado pequeño para las sesiones de un agente. Goose envía las definiciones de todas las herramientas habilitadas en cada petición, y un solo servidor MCP como Playwright añade unas dos docenas de herramientas.

Para conectar Goose a Groq, debes crear una cuenta en el sitio web de Groq y obtener una API key. Puedes generar esta clave en la Groq cloud console:

Después ejecuta goose configure, elige Configure Providers, busca Groq, pega tu API key y selecciona el modelo predeterminado, igual que hicimos con Gemini. También puedes cambiar de proveedor en mitad de una sesión con /model --provider groq. Cambiar de proveedor no afecta a nada más: tus extensiones, recipes y skills siguen funcionando.

Con tantos agentes de IA para programar disponibles, te preguntarás cómo se compara Goose con los demás agentes de terminal. Así queda frente a Claude Code, Codex CLI de OpenAI y OpenCode a fecha de octubre de 2026:

Los cuatro se ejecutan en local en tu terminal y trabajan sobre tus archivos; la diferencia está en dónde se ejecuta el modelo y quién controla el agente.

Cuándo elegir Goose: Quieres un agente gratuito, totalmente de código abierto y bajo una gobernanza neutral, con flexibilidad total de modelos (incluidos los locales), automatización de flujos de trabajo mediante recipes y sin dependencia de un proveedor.

Cuándo elegir Claude Code: Prefieres una experiencia pulida y lista para usar, construida alrededor de los modelos Claude de Anthropic, y no te importa el coste de la suscripción.

Cuándo elegir Codex CLI: Ya pagas una suscripción a ChatGPT y quieres un agente de código abierto optimizado para los modelos de OpenAI.

Cuándo elegir OpenCode: Quieres otro agente de terminal de código abierto y agnóstico de modelos, con una interfaz de usuario de texto (TUI) pulida; es la alternativa más cercana a Goose.

¿Y Cursor? Cursor es sobre todo un IDE centrado en la IA; también tiene un agente CLI, pero su punto fuerte es el editor, así que juega en otra liga. Goose también se distribuye como agente nativo de Agent Client Protocol (ACP), así que puedes controlarlo desde editores como Zed o los IDE de JetBrains, reduciendo la distancia con las alternativas integradas en el IDE sin renunciar a su núcleo de código abierto y agnóstico de modelos.

¿Es Goose completamente gratis?

Sí. Goose es de código abierto bajo la licencia Apache 2.0, sin cuotas de suscripción. Sin embargo, necesitarás acceso a un proveedor LLM. Puedes usar una capa gratuita (Google Gemini, Groq), una API de pago, o ejecutar modelos en local con Ollama para una configuración completamente gratuita.

¿Quién mantiene Goose ahora?

Block creó Goose y lo donó a la Agentic AI Foundation (AAIF) de la Linux Foundation en diciembre de 2025. Desde abril de 2026, el código está en github.com/aaif-goose/goose y la documentación en goose-docs.ai, que sustituye al antiguo sitio block.github.io/goose.

¿Es Goose una alternativa gratuita a Claude Code?

Para muchas tareas, sí. Ambos se ejecutan en local en tu terminal, pero Goose es gratuito, de código abierto y agnóstico de modelos, mientras que Claude Code está pensado para los modelos Claude de Anthropic y requiere una suscripción a Claude o pago por API. Goose también puede funcionar completamente sin conexión con un modelo local. Claude Code ofrece una experiencia más pulida desde el primer momento.

¿Funciona Goose en Windows?

Sí. Goose ofrece una aplicación de escritorio para Windows, y puedes instalar el CLI desde PowerShell, Git Bash o WSL, como se muestra en la sección de instalación en Windows.

¿Puedo usar Goose sin conexión?

Sí, combinando Goose con un proveedor LLM local como Ollama o usando su inferencia local integrada. Así tienes privacidad total y ningún límite de uso, siempre que tu máquina pueda ejecutar un modelo capaz.

¿Qué modelo funciona mejor con Goose?

Goose funciona mejor con modelos que sean buenos llamando a herramientas. Los modelos punteros en la nube dan los resultados más fiables; para uso local, elige el modelo más grande con soporte para llamadas a herramientas que pueda ejecutar tu hardware, como explico en la sección de Ollama.

¿Qué son los servidores MCP y los necesito?

Los servidores MCP (Model Context Protocol) extienden las capacidades de Goose conectándolo a herramientas y servicios externos. Son opcionales. Puedes añadir capacidades como automatización del navegador, integración con GitHub o gestión de Kubernetes sin escribir código personalizado.

¿Cómo añado un servidor MCP a Goose?

Ejecuta goose configure, selecciona Add Extension e introduce el comando que arranca el servidor, o añádelo a la sección extensions de tu archivo config.yaml, como se muestra en la sección de Playwright MCP.

¿Qué diferencia hay entre las recipes y las skills de Goose?

Una recipe es un flujo de trabajo en YAML que lanzas de forma explícita con goose run --recipe o de forma programada. Una skill es un archivo SKILL.md con instrucciones que Goose carga por su cuenta cuando tu petición encaja con ella.

En este artículo, te presenté Goose, un agente de IA de código abierto que se ejecuta en tu máquina, se conecta a decenas de proveedores LLM, incluidos Google Gemini, Groq y modelos locales de Ollama, y extiende sus capacidades a través de servidores MCP, recipes y skills. Te mostré cómo instalar Goose en Linux, macOS y Windows, configurar Google Gemini o un modelo local, usar Playwright MCP para controlar el navegador y automatizar flujos de trabajo con recipes y skills.

Desde su lanzamiento en enero de 2025, Goose ha madurado mucho. A fecha de octubre de 2026, el proyecto ha publicado más de 120 versiones estables, ha superado las 55.000 estrellas en GitHub y ha atraído a más de 450 colaboradores. El ecosistema MCP se ha expandido a decenas de miles de servidores que cubren herramientas de desarrollo (GitHub, VS Code, Docker), suites de productividad (Google Drive, Asana, Slack) y servicios especializados como el Kubernetes MCP Server. Desde su llegada a la Agentic AI Foundation de la Linux Foundation, su desarrollo también avanza bajo una gobernanza neutral, junto a MCP y AGENTS.md, con el respaldo de AWS, Anthropic, Google, Microsoft, OpenAI y otros líderes de la industria.

Si quieres un agente en el que tú elijas el modelo, las herramientas y cuánta libertad le das, Goose es un buen punto de partida. Este cambio hacia desarrolladores basados en máquinas está cambiando nuestra forma de entender las herramientas y los flujos de trabajo de desarrollo.