Ejecutar OpenClaw con Ollama: Guía de Modelos Locales

Llevo un tiempo usando OpenClaw con proveedores de API, y las facturas se acumulan. Incluso modelos baratos como GLM-5 y MiniMax M2.5 cuestan algo, y cada mensaje pasa por el servidor de otra persona. Así que configuré Ollama en la misma máquina y apunté OpenClaw hacia él. Cero coste por token, privacidad total, y la latencia es bastante decente si eliges el modelo adecuado para tu hardware.

Esta guía cubre cómo hacer que OpenClaw se comunique con Ollama, qué modelos funcionan bien para diferentes niveles de hardware, y qué hacer cuando tu máquina no puede con los modelos más grandes. Respuesta corta a esto último: Nanbeige4.1-3B es sorprendentemente bueno para ser un modelo de 3B.

Por Qué Ejecutar Modelos Locales con OpenClaw

Tres razones para molestarse con esto en lugar de simplemente usar una API:

La contrapartida es real: los modelos locales son más lentos y menos capaces que Claude Opus o GPT-5. Pero para las tareas cotidianas de OpenClaw como responder mensajes y ejecutar trabajos programados, un modelo local decente lo maneja bien.

Requisitos de Hardware

Esta es la parte que la mayoría de guías se equivocan. Te dicen el tamaño del modelo y se olvidan de la experiencia real. Esto es lo que he encontrado ejecutando diferentes niveles.

La VRAM Es Lo Que Importa

Los modelos se ejecutan en la VRAM de la GPU cuando está disponible. Si el modelo no cabe en la VRAM, se desborda a la RAM del sistema y se vuelve mucho más lento. La inferencia solo con CPU funciona, pero espera respuestas 5-10x más lentas.

Configuraciones Recomendadas

Instalar Ollama

Un solo comando:

curl -fsSL https://ollama.ai/install.sh | sh

En macOS, descarga desde ollama.ai o usa Homebrew:

brew install ollama

Verifica que está funcionando:

ollama --version
ollama list

Si ollama list funciona, estás listo.

Elegir el Modelo Correcto

No todos los modelos funcionan bien con OpenClaw. Necesitas soporte de tool calling (para que el agente pueda usar sus herramientas) e idealmente buen seguimiento de instrucciones. Aquí están los modelos que he probado, ordenados por nivel de hardware.

Mejores Modelos por Nivel

* Subida comunitaria en Ollama — ver sección de Nanbeige más abajo.

Mis Recomendaciones

• Mac Mini 32GB o GPU de 16GB+: qwen2.5-coder:32b como principal, qwen3:8b como fallback
• 16GB RAM, sin GPU: qwen3:8b como principal, qwen3:4b como fallback
• 8GB RAM: nanbeige4.1-3b o qwen3:4b

Descarga tu modelo elegido:

ollama pull qwen2.5-coder:32b
# o para hardware más modesto:
ollama pull qwen3:8b
# o para hardware mínimo:
ollama pull tomng/nanbeige4.1

Nanbeige4.1-3B: La Sorpresa Económica

Este modelo me pilló desprevenido. Nanbeige4.1-3B es un modelo de 3B parámetros de Nanbeige Lab (un equipo de Kanzhun/BOSS Zhipin) que rinde muy por encima de su categoría. Mira estos números:

Un modelo de 3B superando a Qwen3-32B en benchmarks de programación. Obtiene 56.5 en BFCL-V4 (uso de herramientas), lo cual importa porque OpenClaw depende del tool calling. También puede manejar más de 500 rondas de invocaciones de herramientas para tareas de búsqueda profunda. No conozco otro modelo de menos de 4B que pueda hacer eso.

Cuándo Usarlo

• Tu máquina tiene 8GB de RAM y no tiene GPU
• Quieres un modelo de respaldo que use recursos mínimos
• Estás ejecutándolo en un Raspberry Pi 5 o placa ARM similar
• Necesitas un fallback de emergencia cuando tu modelo principal es demasiado lento

Cuándo NO Usarlo

• Tienes hardware para modelos más grandes — los de 8B+ seguirán dando mejores resultados en tareas complejas
• Necesitas escritura creativa extensa o conversación con matices
• Estás haciendo refactorización pesada de código en múltiples archivos

Instalar Nanbeige4.1-3B

El modelo está disponible a través de subidas comunitarias en Ollama. La versión más popular con soporte de herramientas:

ollama pull tomng/nanbeige4.1

También puedes importar el GGUF desde HuggingFace si quieres una cuantización específica:

# Download the Q4_K_M quantization (smallest useful size, ~2.3GB)
# From: huggingface.co/Edge-Quant/Nanbeige4.1-3B-Q4_K_M-GGUF

# Create a Modelfile
cat > Modelfile << 'EOF'
FROM ./Nanbeige4.1-3B-Q4_K_M.gguf
PARAMETER temperature 0.6
PARAMETER top_p 0.95
PARAMETER repeat_penalty 1.0
TEMPLATE """{{- if .System }}{{ .System }}{{ end }}
{{- range .Messages }}
{{- if eq .Role "user" }}
{{ .Content }}
{{- else if eq .Role "assistant" }}
{{ .Content }}
{{- end }}
{{- end }}"""
EOF

ollama create nanbeige4.1-3b -f Modelfile

Configurar OpenClaw para Ollama

Paso 1: Habilitar Ollama

Establece la variable de entorno que le dice a OpenClaw que busque Ollama:

export OLLAMA_API_KEY="ollama-local"

O añádelo permanentemente a tu entorno de OpenClaw:

# Add to ~/.openclaw/.env
echo 'OLLAMA_API_KEY=ollama-local' >> ~/.openclaw/.env

El valor no importa (Ollama no lo verifica), pero OpenClaw lo necesita configurado para habilitar el proveedor de Ollama.

Paso 2: Verificar el Descubrimiento

OpenClaw descubre automáticamente los modelos de Ollama con soporte de herramientas. Comprueba lo que encontró:

openclaw models list --local

Deberías ver tus modelos descargados listados. Si un modelo no aparece, puede que no reporte soporte de herramientas. Aún puedes usarlo añadiendo configuración explícita (ver Paso 3).

Paso 3: Establecer Tu Modelo

Para una configuración sencilla con un solo modelo:

openclaw models set ollama/qwen2.5-coder:32b

O edita tu archivo de configuración (~/.openclaw/openclaw.json):

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen2.5-coder:32b"
      }
    }
  }
}

Paso 4: Configurar Fallbacks

Los fallbacks importan más con modelos locales porque un solo modelo puede ser demasiado lento o quedarse sin contexto. Configura una cadena:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen2.5-coder:32b",
        "fallbacks": [
          "ollama/qwen3:8b",
          "ollama/tomng/nanbeige4.1"
        ]
      }
    }
  }
}

Si el modelo de 32B se atasca con un contexto largo, OpenClaw pasa al de 8B, y luego a Nanbeige.

Ejemplo de Configuración Completa (Hardware de Gama Media)

Aquí tienes una configuración completa para un Mac Mini de 32GB:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen2.5-coder:32b",
        "fallbacks": ["ollama/qwen3:8b"]
      },
      "imageModel": {
        "primary": "ollama/mistral-small3.2:24b"
      }
    }
  }
}

Ejemplo de Configuración Completa (Hardware de Gama Baja)

Para una máquina con 8GB de RAM o Raspberry Pi:

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/tomng/nanbeige4.1",
        "fallbacks": ["ollama/qwen3:1.7b"]
      }
    }
  }
}

Configuración Explícita del Proveedor (Ollama Remoto)

Si Ollama se ejecuta en una máquina diferente (por ejemplo, un servidor GPU en tu LAN), necesitas configuración explícita en lugar del descubrimiento automático:

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://192.168.1.50:11434",
        "apiKey": "ollama-local",
        "api": "ollama",
        "models": [
          {
            "id": "qwen2.5-coder:32b",
            "name": "Qwen 2.5 Coder 32B",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 32768,
            "maxTokens": 8192
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen2.5-coder:32b"
      }
    }
  }
}

Configuración Híbrida: Local + API como Fallback

La configuración que realmente recomiendo es híbrida. Modelo local como principal, API económica como fallback para cuando el modelo local no da abasto. Obtienes privacidad y coste cero para el 90% de los mensajes, y la calidad de la API está ahí cuando la necesitas.

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/qwen2.5-coder:32b",
        "fallbacks": [
          "ollama/qwen3:8b",
          "zai/glm-5"
        ]
      }
    }
  }
}

Con esta configuración, OpenClaw prueba primero el modelo local de 32B. Si el contexto es demasiado largo o el modelo da error, pasa al de 8B local. Si ese también falla, recurre a la API de GLM-5 (que es barata). Puedes configurar GLM-5 o MiniMax M2.5 como tu fallback de API siguiendo la guía de mejores modelos open source.

Cambiar de Modelo Sobre la Marcha

No tienes que reiniciar OpenClaw para cambiar de modelo. Usa el comando /model en el chat:

/model                        # Show available models
/model list                   # Full list with providers
/model ollama/qwen3:8b        # Switch to a different model
/model status                 # Check current model + auth

Útil para probar: descarga un nuevo modelo con ollama pull, y aparece automáticamente en /model list (con el descubrimiento automático habilitado).

Ajuste de Rendimiento

Ventana de Contexto

Ollama reporta la ventana de contexto desde los metadatos del modelo. Puedes sobreescribirla en la configuración explícita:

{
  "models": {
    "providers": {
      "ollama": {
        "models": [{
          "id": "qwen2.5-coder:32b",
          "contextWindow": 65536,
          "maxTokens": 16384
        }]
      }
    }
  }
}

Las ventanas de contexto más grandes usan más VRAM. Si estás alcanzando los límites de memoria, reduce contextWindow.

Ejecutar Múltiples Modelos

Ollama puede mantener múltiples modelos cargados si tienes suficiente VRAM. Configura OLLAMA_NUM_PARALLEL para controlar la concurrencia:

OLLAMA_NUM_PARALLEL=2 ollama serve

Con suficiente VRAM, puedes ejecutar un modelo de programación y uno general simultáneamente, alternando entre ellos con /model en OpenClaw.

Capas de GPU

Si tienes una GPU pero no suficiente VRAM para el modelo completo, Ollama descarga automáticamente algunas capas a la CPU. Puedes controlar esto:

OLLAMA_GPU_LAYERS=35 ollama serve

Más capas en GPU = más rápido pero más VRAM. Experimenta para encontrar tu punto ideal.

Solución de Problemas

ollama list
curl http://localhost:11434/api/tags

ollama serve

curl http://localhost:11434/api/tags

ollama pull tomng/nanbeige4.1

Consideraciones de Seguridad

Ejecutar modelos localmente es inherentemente más privado que las llamadas a API, pero no te saltes lo básico:

• Ollama no tiene autenticación: cualquiera en tu red que pueda alcanzar el puerto 11434 puede usar tus modelos. Vincúlalo a localhost o usa un firewall.
• Descargas de modelos: Ollama descarga modelos desde ollama.com. Si te preocupa la seguridad, verifica los checksums de los modelos o usa instalaciones sin conexión.
• Seguridad de OpenClaw: los modelos locales no cambian el modelo de amenazas de OpenClaw. Sigue la guía de hardening de seguridad para la configuración del gateway, modo sandbox y revisión de skills.

Guías Relacionadas

• Guía de Configuración de OpenClaw — instalación completa en VPS de Hetzner o Mac Mini
• Mejores Modelos Open Source para OpenClaw — modelos basados en API (GLM-5, MiniMax M2.5) para cuando lo local no es suficiente
• Búsqueda DuckDuckGo para OpenClaw — búsqueda web gratuita que combina bien con modelos locales
• Guía de Seguridad de OpenClaw — proteger tu instancia, especialmente relevante cuando se ejecuta en una LAN
• Mejores Dashboards de OpenClaw — dashboards que muestran uso de modelos y coste (útil para rastrear el uso local a $0 vs gasto en fallback de API)
• Alternativas a OpenClaw — otras plataformas con su propio soporte de modelos locales

Los modelos locales con Ollama no van a reemplazar a Claude Opus para trabajo complejo. Pero cubren el 80-90% de lo que uso OpenClaw: responder mensajes, ejecutar cron jobs, búsquedas, automatizaciones. La configuración híbrida (local como principal + API como fallback) significa privacidad y coste cero la mayor parte del tiempo, con calidad de API cuando realmente la necesitas.

Empieza con el modelo que se ajuste a tu hardware. Si tienes un Mac Mini, ve directo a qwen2.5-coder:32b. Si estás en un VPS económico con 8GB de RAM, descarga Nanbeige4.1-3B y sorpréndete.

Para el resto del stack de OpenClaw: guía de configuración, recomendaciones de modelos de API, búsqueda web gratuita, hardening de seguridad, dashboards y plataformas alternativas.