🤖 Codename Goose de 0 a héroe: Guía punk para dominar el agente IA más potente de 2025

⚡️ ¿Qué demonios es Goose y por qué debería importarte?

Imagina un asistente de IA que no solo habla contigo, sino que hace cosas por ti. Codename Goose es un agente open source creado por Block (la gente de Square y CashApp) que puede ejecutar código, buscar en la web, manipular archivos y automatizar tareas complejas sin necesidad de que escribas una sola línea.

A diferencia de los chatbots normales que solo generan texto, Goose actúa directamente en tu sistema, funcionando 100% en local (adiós a la dependencia de la nube) y con capacidad para conectarse con cualquier LLM que elijas, desde Claude y GPT hasta modelos de Ollama que corren en tu máquina.

1️⃣ Instalación multiplataforma: ponlo a funcionar en 10 minutos

Linux (Ubuntu/Debian y derivados)

# Instala dependencias
sudo apt update
sudo apt install bzip2 curl -y

# Descarga e instala Goose
curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash

# Verifica la instalación
goose -v

Windows con WSL (Recomendado)

1. Instala WSL si no lo tienes: wsl --install
2. Abre Ubuntu en WSL
3. Sigue los pasos de Linux

Windows nativo

1. Descarga el instalador desde GitHub
2. Ejecuta el instalador .exe
3. Abre una terminal PowerShell y verifica con goose -v

macOS

# Usando Homebrew
brew tap block/goose
brew install goose

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

2️⃣ Primeros pasos: configura tu cerebro IA

Una vez instalado, necesitas conectar Goose con un modelo de IA. Lo primero es ejecutar el asistente de configuración:

goose configure

Te preguntará qué proveedor quieres usar. Las opciones más habituales son:

• OpenAI: Requiere API key, usa GPT-4o
• Anthropic: Requiere API key, usa Claude 3.5 Sonnet
• OpenRouter: Centraliza varios modelos, buena opción para experimentar
• Ollama: Modelos 100% locales como DeepSeek R1

# Configuración con OpenRouter (recomendada para punk novatos)
GOOSE_PROVIDER=openrouter
GOOSE_MODEL=anthropic/claude-3.5-sonnet
# O con Ollama local (para punks avanzados)
GOOSE_PROVIDER=ollama
GOOSE_MODEL=deepseek-r1

Anota tu API key cuando te la pida, o edita el archivo de configuración en ~/.config/goose/config.yaml.

3️⃣ El poder de las extensiones: las herramientas de tu agente punk

Aquí está la magia real de Goose: puede usar extensiones (basadas en el protocolo MCP) para interactuar con tu sistema y herramientas externas.

Extensiones incorporadas

Goose viene con extensiones predefinidas que puedes activar con goose configure o editando tu archivo de configuración:

Activar extensiones (modo punk rápido)

En lugar de usar el asistente de configuración, puedes editar directamente el archivo ~/.config/goose/config.yaml para activar las extensiones que quieras:

GOOSE_PROVIDER: openrouter
GOOSE_MODEL: anthropic/claude-3.5-sonnet
extensions:
  computercontroller:
    enabled: true
    name: computercontroller
    type: builtin
  developer:
    enabled: true
    name: developer
    type: builtin
  memory:
    enabled: true
    name: memory
    type: builtin

Extensiones MCP personalizadas

Puedes añadir tus propias extensiones, o extensiones de terceros, siguiendo este formato:

# Añadir a tu config.yaml
mcp-tavily-search:
  name: mcp-tavily-search
  cmd: npx
  args: [-y, mcp-tavily-search]
  enabled: true
  envs: { 'TAVILY_API_KEY': 'tu-api-key-aquí' }
  type: stdio

Algunas extensiones MCP útiles para empezar:

• mcp-brave-search: Búsquedas web actualizada
• mcp-tavily-search: Motor de búsqueda especializado
• mcp-wsl-exec: Ejecutar comandos en WSL
• mcp-memory-libsql: Almacenamiento persistente

4️⃣ Interfaz de usuario: terminal, VS Code y navegador

Terminal (CLI)

La forma más punk de usar Goose es en terminal. Comandos esenciales:

# Iniciar nueva sesión
goose session

# Reanudar última sesión
goose session -r

# Iniciar con nombre específico
goose session -n miproyecto

# Añadir extensión específica para esta sesión
goose session --with-builtin computercontroller

VS Code (Extension)

Para los que prefieren un editor de código, instala la extensión «Wingman Goose» desde el Marketplace:

1. Abre VS Code
2. Presiona Ctrl+Shift+X (o Cmd+Shift+X en Mac)
3. Busca «Wingman Goose»
4. Instala y reinicia VS Code

Esta extensión permite:

• Chatear con Goose directamente en VS Code
• Seleccionar código y realizar acciones sobre él
• Utilizar atajos de teclado para tareas comunes

Configuración en contenedores Docker

Para los verdaderos punks que quieren todo aislado, puedes ejecutar Goose en Docker:

# Crear Dockerfile
cat > Dockerfile << 'EOF'
FROM ubuntu:24.04
RUN apt-get update && apt-get install -y curl bzip2
RUN curl -fsSL https://github.com/block/goose/releases/download/stable/download_cli.sh | bash
ENV GOOSE_PROVIDER=openrouter
ENV GOOSE_MODEL=anthropic/claude-3.5-sonnet
ENV OPENROUTER_API_KEY=tu-api-key-aquí
CMD ["goose", "session"]
EOF

# Construir y ejecutar
docker build -t goose-punk .
docker run -it --rm goose-punk

5️⃣ Casos de uso reales con ejemplos paso a paso

Caso 1: Navegación web automática

Vamos a pedirle a Goose que busque información sobre IA generativa, capture datos y genere un resumen.

# Asegúrate de tener la extensión Computer Controller activada
goose session --with-builtin computercontroller

Prompt a usar:

Busca información sobre los últimos avances en IA generativa, visita al menos 3 sitios diferentes, y crea un resumen de 300 palabras con los puntos más importantes. Guarda el resultado en un archivo llamado «resumen_ia_generativa.md» en mi carpeta de Documentos.

Goose ejecutará estos pasos automáticamente:

1. Abrir el navegador y buscar información
2. Visitar múltiples sitios y extraer información relevante
3. Generar un resumen coherente
4. Crear el archivo en tu carpeta de Documentos

Caso 2: Instalación y configuración de un contenedor Docker

Vamos a pedirle que instale y configure un contenedor de PostgreSQL.

# Necesitas Computer Controller y Developer
goose session --with-builtin computercontroller --with-builtin developer

Prompt a usar:

Instala un contenedor Docker con PostgreSQL 16, configúralo para usar el puerto 5433 (para no interferir con instalaciones existentes), crea una base de datos llamada ‘proyecto_punk’, y verifica que todo funcione correctamente.

Goose ejecutará estos pasos:

1. Verificar si Docker está instalado (e indicarte cómo instalarlo si no lo está)
2. Crear un archivo docker-compose.yml con la configuración adecuada
3. Ejecutar docker-compose up -d
4. Verificar la conexión a la base de datos
5. Crear la base de datos proyecto_punk
6. Mostrarte comandos para conectarte y usarla

# Ejemplo del docker-compose.yml que Goose creará
version: '3.8'
services:
  postgres:
    image: postgres:16
    ports:
      - "5433:5432"
    environment:
      POSTGRES_PASSWORD: punkrock
      POSTGRES_USER: punk
    volumes:
      - postgres_data:/var/lib/postgresql/data
volumes:
  postgres_data:

Caso 3: Análisis y refactorización de código

Vamos a pedirle a Goose que analice un código Python y lo mejore.

# Primero, creemos un archivo de ejemplo
cat > codigo_feo.py << 'EOF'
def f(x, y):
  z = x + y
  if z > 10:
    print("Mayor que 10")
  else:
    print("Menor o igual que 10")
  return z

def g(lista):
  r = []
  for i in lista:
    r.append(f(i, 10))
  return r

resultado = g([1, 5, 15, 20])
print(resultado)
EOF

# Ahora ejecutemos Goose
goose session --with-builtin developer

Prompt a usar:

Analiza el archivo codigo_feo.py en mi directorio actual. Refactorízalo para seguir las mejores prácticas de Python (PEP 8), añade docstrings, mejora los nombres de variables y funciones, y optimiza el código si es posible. Guarda la versión mejorada como codigo_limpio.py y explica los cambios que has hecho.

6️⃣ Extensiones avanzadas y hacks punk

Crear tu propia extensión MCP

Las extensiones MCP son simplemente programas que siguen el protocolo Model Context Protocol. Puedes crear tu propia extensión en cualquier lenguaje que pueda leer de stdin y escribir en stdout:

# Ejemplo mínimo en Python
import json
import sys

def main():
    while True:
        line = sys.stdin.readline()
        if not line:
            break

        request = json.loads(line)

        if request["type"] == "execute":
            # Haz algo con request["inputs"]["comando"]
            resultado = "Ejecutado: " + request["inputs"]["comando"]

            response = {
                "id": request["id"],
                "type": "result",
                "result": {
                    "output": resultado
                }
            }

            sys.stdout.write(json.dumps(response) + "\n")
            sys.stdout.flush()

if __name__ == "__main__":
    main()

Para usar esta extensión:

# Guarda el código como mi_extension.py
chmod +x mi_extension.py

# Añade a tu config.yaml
mi-extension-punk:
  name: mi-extension-punk
  cmd: python
  args: [/ruta/a/mi_extension.py]
  enabled: true
  type: stdio

Automatización avanzada con Goose

Puedes usar Goose para automatizar flujos complejos como este:

# Crea un archivo de instrucciones
cat > instrucciones_punk.txt << 'EOF'
1. Busca las 5 bibliotecas de Python más populares para machine learning
2. Para cada una, extrae su repositorio GitHub
3. Analiza sus estadísticas (estrellas, forks, issues)
4. Crea una tabla comparativa en Markdown
5. Genera un gráfico de barras usando matplotlib
6. Guarda todo en un informe llamado "comparativa_ml_punk.md"
EOF

# Ejecútalo con Goose
goose run instrucciones_punk.txt

7️⃣ Integración con VS Code: el verdadero hackeo

La extensión Wingman Goose te permite llevar la integración al siguiente nivel:

Configuración avanzada de VS Code

Añade estas configuraciones en tu settings.json para optimizar Goose:

{
  "wingman-goose.autoSuggest": true,
  "wingman-goose.defaultModel": "anthropic/claude-3.5-sonnet",
  "wingman-goose.customPrompt": "Actúa como un programador punk experimentado que prefiere soluciones elegantes y optimizadas.",
  "wingman-goose.maxTokenLength": 8000
}

Atajos de teclado personalizados

Configura atajos de teclado para acciones comunes:

// keybindings.json
[
  {
    "key": "ctrl+alt+g",
    "command": "wingman-goose.askGoose",
    "when": "editorTextFocus"
  },
  {
    "key": "ctrl+alt+e",
    "command": "wingman-goose.explainCode",
    "when": "editorHasSelection"
  }
]

8️⃣ Solución de problemas comunes

9️⃣ Comparación con otros agentes IA

🎸 Conclusión: el futuro es de los agentes autónomos

Codename Goose es más que un asistente IA – es un verdadero agente que puede ejecutar tareas complejas en tu nombre. No solo «habla» de código, sino que lo escribe, lo ejecuta y lo depura por ti.

A medida que esta tecnología evolucione, veremos agentes cada vez más capaces que podrán manejar flujos de trabajo enteros, desde la concepción hasta la implementación. Goose es un vistazo a ese futuro.

¿Has probado Goose? ¿Tienes alguna extensión MCP favorita o caso de uso que quieras compartir? ¡Comenta abajo y mantén vivo el espíritu punk de la automatización!