Ejecuta agentes sin API: Guía OpenClaw 2026

OpenClaw es un framework open-source que transforma modelos de lenguaje en agents autónomos capaces de ejecutarse completamente en local. Instalando Ollama, LM Studio o Jan como gateway, configurás tu propia infraestructura de agents sin pagar APIs, sin rate limits, sin dependencias de OpenAI o Anthropic. Hardware mínimo: GPU de 24GB VRAM. Funciona offline. Ganás privacidad total.

¿Qué es OpenClaw y por qué ejecutarlo localmente?

OpenClaw es un framework que convierte modelos de lenguaje en agents persistentes — es decir, entidades de IA que pueden tomar decisiones, ejecutar acciones, acceder a herramientas externas y recordar contexto entre ejecuciones. Diferencia clave: los agents tradicionales son stateless (responden preguntas puntuales), mientras que OpenClaw crea agentes con memoria y autonomía.

Ahora bien, la pregunta que te hacés es: ¿por qué ejecutar OpenClaw localmente en vez de usar la API de OpenAI o Anthropic? Tres razones concretas. Primero, costo: con API pagadas, si tu agent corre 24/7 procesando documentos, analizando logs, o automatizando DevOps, gastás USD 2000-5000 mensuales en tokens. Localmente, el costo es cero (más allá de la electricidad de tu GPU). Segundo, sin rate limits: OpenAI te deja 90 requests por minuto en GPT-4. Localmente, tu único límite es el ancho de banda y el VRAM. Tercero, privacidad: tus datos nunca salen del datacenter, nunca pasan por servidores de terceros, cumplís regulaciones como RGPD sin problemas.

El trade-off es hardware. Ejecutar un modelo de 70B parámetros requiere 24GB VRAM mínimo. Y la latencia es peor: un modelo local tarda 5-15 segundos en generar respuesta, mientras que OpenAI tarda 1-2. Para automatización asincrónica (DevOps, análisis de datos, tareas nocturnas), eso está bien. Para chat interactivo, es lento.

Requisitos de hardware para modelos locales

Acá viene lo importante: no es lo mismo ejecutar un modelo de 7B que uno de 70B. El VRAM y RAM que necesitás varían mucho.

¿Tenés una RTX 3060 con 12GB? Podés correr Mistral 13B o Qwen 14B, sin problemas. ¿RTX 4090? Hacés correr Llama 70B cómodamente. ¿Solo CPU? Existe AirLLM, una técnica de quantización extrema que reduce un modelo de 70B a 4GB VRAM, pero la latencia se dispara a 30-60 segundos.

La recomendación directa: si vas en serio con OpenClaw localmente, invertí en GPU. Un RTX 4070 (USD 400-500) es el punto óptimo hoy. RTX 4090 (USD 1600+) si necesitás correr 70B sin esperar. En Mac, M2 Max zafa para 13B, M3 Max para 32B.

Guía step-by-step: Ollama + OpenClaw

Ponele que ya decidiste: querés ejecutar OpenClaw con Ollama. Estos son los pasos exactos. Para más detalles técnicos, mirá mantener tus datos privados localmente.

Paso 1: Instalar Ollama

Bajate Ollama desde ollama.ai. Funciona en Windows, Mac, Linux. Instalación estándar, siguiente, siguiente, fin.

Paso 2: Descargar un modelo

Abrís terminal y corrés:

ollama pull qwen2.5-coder:14b

Eso descarga Qwen 2.5 Coder de 14B parámetros (excelente para agents que necesitan escribir código). Alternativas recomendadas: ollama pull llama2:13b, ollama pull mistral:7b. El download tarda 5-20 minutos dependiendo de tu conexión y el tamaño del modelo.

Paso 3: Verificar que Ollama esté corriendo

Ollama inicia un servidor automáticamente en http://127.0.0.1:11434. Para verificar:

curl http://127.0.0.1:11434/api/tags

Si te devuelve una lista con el modelo que descargaste, listo.

Paso 4: Configurar OpenClaw

En el archivo de configuración de OpenClaw (usualmente agents.config.json o .openclaw/config), agregás:

"gateway": { "type": "ollama", "baseUrl": "http://127.0.0.1:11434" }, "model": { "primary": "qwen2.5-coder:14b" }

Paso 5: Testear

Corrés tu primer agent:

openclaw agent run my-agent --model qwen2.5-coder:14b

Si funciona, verás la respuesta del modelo en 5-15 segundos. Ganaste.

Alternativa gráfica: LM Studio vs Jan vs Lemonade

No todos quieren CLI. Si preferís interfaz gráfica, tenés tres opciones que integran bien con OpenClaw.

Si estás empezando, LM Studio. Es la más intuitiva: descargás modelo, le das play, listo. Si querés control fino sobre quantización, batch size, context windows, vas con Jan. Si necesitás algo que corra en un servidor sin interfaz gráfica, Lemonade.

Configuración avanzada: fallback y routing inteligente

Una vez que funciona lo básico, la configuración crece. Porque el problema real es este (spoiler: la resiliencia): qué pasa si tu modelo local se cuelga, falla, o el VRAM se llena. Necesitás fallback a un modelo en la nube. Más contexto en optimizar rendimiento con GPU dedicada.

En OpenClaw, esto se configura así:

"defaults": { "model": { "primary": "qwen2.5-coder:14b", "fallback": ["gpt-4-turbo", "claude-3-sonnet"] } }

Si tu agente intenta correr con el modelo local y falla (timeout, OOM, error), automáticamente retintenta con GPT-4 Turbo. Si eso también falla, probá Claude 3 Sonnet. Costo: pagas solo los fallbacks, no la ejecución normal.

Otra configuración útil es imageModel separado. Si tu agent genera imágenes, no todas las imágenes las generás localmente (Stable Diffusion requiere GPU extra), sino que delegás a Replicate o Hugging Face:

"imageModel": { "primary": "local-diffusion", "fallback": "replicate" }

Comandos de diagnóstico útiles:

• openclaw agents config get — ver configuración actual
• openclaw models list — ver modelos disponibles (locales + remotos)
• openclaw agents status — estado de agents en ejecución

Errores comunes en la configuración

Error 1: baseUrl incorrecto o typo en el nombre del modelo

Síntoma: “Connection refused” o “Model not found”. Causa: escribiste http://localhost:11434 en vez de http://127.0.0.1:11434 (algunas máquinas no resuelven localhost), o el nombre del modelo está mal: qwen:14b en vez de qwen2.5-coder:14b. Solución: copiá y pegá la URL y el nombre exacto del modelo desde ollama list.

Error 2: No reiniciaste OpenClaw tras cambios de config

Cambias agents.config.json, probás el agent, sigue usando el modelo viejo. OpenClaw cachea la configuración al startup. Solución: matá el proceso (Ctrl+C) y volvé a ejecutar. Si usás Docker, reiniciá el container.

Error 3: Problema de networking con Docker

Si corrés OpenClaw en Docker pero Ollama está en la máquina host, Docker no ve 127.0.0.1:11434 porque vive en otro namespace de red. Síntoma: timeout infinito. Solución: usá host.docker.internal:11434 en Windows/Mac, o 172.17.0.1:11434 en Linux, o mejor aún, corre Ollama también en Docker en la misma red. Ya lo cubrimos antes en plataformas de integración disponibles.

Error 4: Stale session cache

OpenClaw a veces cachea sesiones viejas en ~/.openclaw/cache. Si ves comportamientos raros (agente usa modelo viejo, se olvida del contexto), limpiá: rm -rf ~/.openclaw/cache/*.

Error 5: VRAM exhausto durante ejecución

El modelo cargó bien en local, pero cuando el agent genera output muy largo (más de 4000 tokens), VRAM se llena y se congela. Solución: reducí context_window en config, o usá quantización (fp8 en vez de fp16). Un modelo de 70B en fp16 ocupa 140GB VRAM; en fp8, 70GB; en int8, 35GB.

Optimización de rendimiento y latencia

Una vez que funciona, querés que sea rápido. La latencia típica de un modelo local es 5-15 segundos. Podés optimizar.

Quantización

Descargar un modelo en fp8 (8 bits) en vez de fp16 (16 bits) reduce a la mitad el VRAM y acelera un poco la ejecución. En Ollama:

ollama pull qwen2.5-coder:14b-q8_0 (quantizado a 8 bits)

Tradeoff: 1-2% loss de calidad, pero ganás 20-30% speedup. Vale la pena en la mayoría de casos.

Batch size

Si el agent procesa múltiples requests en paralelo, aumentá batch_size en config. Valor default: 1. Si tenés VRAM, probá 4 o 8. Procesa más requests en paralelo, misma latencia total.

Context window

Algunos modelos soportan context de 128K tokens. Usarlos todos ralentiza el modelo exponencialmente. Limita el agent a context_window 8K o 16K, suficiente para la mayoría de tareas. En config: Cubrimos ese tema en detalle en cumplir requisitos de seguridad empresarial.

"model": { "contextWindow": 8192 }

Monitoreo real

Para saber dónde está el cuello de botella, monitoreá GPU y latencia:

nvidia-smi (cada 1 segundo: watch -n 1 nvidia-smi)

Si VRAM está al 80-90% del máximo del modelo, ahí está el límite. Si la GPU está al 50-60%, probablemente el CPU es el cuello de botella (la GPU espera a que el CPU prepare tokens).

Preguntas frecuentes

¿Necesito dejar corriendo Ollama todo el tiempo?

No, pero se recomienda. Ollama cachea modelos en VRAM entre ejecuciones. Si lo apagás, la próxima ejecución descarga el modelo a memoria (5-30 segundos de overhead). Si lo dejás corriendo, ese overhead desaparece. En el esquema de DevOps (agents autónomos 24/7), definitivamente sí.

¿Puedo usar OpenClaw completamente offline, sin internet?

Sí, si no usás fallback a APIs remotas. Descargás el modelo en local, configurás OpenClaw para apuntar solo a http://127.0.0.1:11434, sin primary_fallback en la nube, y funciona 100% offline. El único Internet que necesitás es para descargar el modelo la primera vez.

¿Cuál es la diferencia entre Ollama, LM Studio y Jan?

Ollama es CLI, más ligero, más rápido de configurar. LM Studio agrega UI intuitiva, bueno para experimentar. Jan es UI moderna con control avanzado, bueno para desarrolladores. Todos exponen la misma API OpenAI-compatible, así que OpenClaw funciona con los tres igual.

¿Puedo ejecutar dos modelos en paralelo en la misma GPU?

Teóricamente sí con model sharing y TVM, pero en la práctica no. Dos modelos de 35B cada uno requieren 70GB VRAM; si tu GPU tiene 24GB, no entra ni uno. La solución es multi-GPU o reducir el context window de cada modelo. OpenClaw soporta multi-GPU configurando "gpuIds": [0, 1, 2].

¿Qué modelo recomiendas para OpenClaw agents?

Depende del caso. Para DevOps y code generation, Qwen 2.5 Coder 14B es excelente (especializado en código). Para análisis general y búsqueda, Mistral 7B es rápido y preciso. Para tareas heavy, Llama 70B o Qwen 72B. En Argentina, si tenés hosting, donweb.com soporta instancias GPU para estos casos.

Conclusión

Ejecutar OpenClaw localmente es viable hoy. No es magia (sí es lento comparado con APIs cloud, sí requiere GPU cara), pero el trade-off vale si querés cero costos recurrentes, cero rate limits, privacidad garantizada, y agentes corriendo 24/7 sin sorpresas de factura.

El setup es directo: Ollama + modelo de 14-70B + configurar OpenClaw en 10 minutos. Si querés GUI, LM Studio o Jan. Si necesitás fallback inteligente a APIs remotas, ese también se configura fácil.

Lo que cambió en 2026 es que los modelos open-source (Qwen, Llama, Mistral) ahora compiten de verdad con GPT-4 en muchas tareas, así que el costo de bajar de la nube es menor. Hace dos años, usar modelo local te costaba 30% de accuracy. Ahora, 95% de accuracy en 95% de tareas. Eso justifica la compra de GPU.

Si vos o tu equipo necesitan agentes locales ya, testea con Ollama + Mistral 7B (liviano, rápido) este week. Si zafa, upgradea a Qwen 14B. Después ya decidís si invertís en GPU más potente.

Fuentes

• OpenClaw — Models documentation
• OpenClaw — Local Models Gateway Setup
• DataCamp — OpenClaw + Ollama Tutorial
• Dev.to — Ejecutar LLMs locales en 2026: Ollama, LM Studio, Jan
• GitHub — OpenClaw Agents Documentation