# OpenClaw con un modelo local de Ollama: montaje y seguridad

> Monta OpenClaw como agente local sobre Ollama: instalación, pasarela, modelo, espacio de trabajo, tareas programadas, un canal de chat y qué restringir antes.

- Publicado: 2026-09-09
- Revisado: 2026-11-15
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: OpenClaw, Ollama, Agentes de IA, Tutorial
- URL canónica: https://vorluxai.com/blog/openclaw-ollama-local-agent-setup-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar esta guía tendrás una pasarela de OpenClaw en una máquina tuya, respondiendo con un modelo que Ollama sirve en ese mismo equipo. Tendrá su espacio de trabajo, un canal de chat, una tarea programada y permisos más estrictos que los de fábrica.

Cada comando y cada clave de configuración se comprobó el 15 de noviembre de 2026, por dos vías. Primero con la documentación de OpenClaw, que describe la última versión estable, la 2026.11.3. Después con la salida de `--help` de la pasarela 2026.7.1-2 que tenemos en producción. Donde difieren, decimos a qué versión se aplica cada cosa.

> **TL;DR**
> - **Se instala con un comando.** `ollama launch openclaw` instala OpenClaw, escribe la configuración del proveedor y arranca la pasarela.
> - **Usa la API nativa de Ollama.** La documentación de OpenClaw avisa de que la URL `/v1` rompe las llamadas a herramientas.
> - **La configuración de fábrica se fía del modelo.** El sandbox viene apagado y el agente puede ejecutar comandos con tu usuario. Arréglalo antes de conectar un canal.
> - **El tamaño del modelo se nota en el criterio.** En nuestra prueba, un modelo de 8B llamó a la shell para responder preguntas sencillas. Uno de 26B no.
> - **"ok" no significa "hecho".** Una ejecución programada puede acabar en `ok` aunque su comando fallara. Mira la ejecución, no el estado.

## Para quién es, y cuándo no hacerlo

Es para ti si quieres un asistente que lea tus archivos, siga un horario y te responda en un chat, con el modelo en tu hardware. No es buena idea en tres casos:

- **Lo van a compartir personas que no se fían entre sí.** La [página de seguridad](https://docs.openclaw.ai/gateway/security) de OpenClaw parte de una sola frontera de confianza por pasarela y dice que no aísla a usuarios hostiles entre sí.
- **El agente va a leer correo o páginas web no fiables con las herramientas activadas.** La [página sobre inyección de prompt](https://docs.openclaw.ai/gateway/security/prompt-injection) dice que los modelos pequeños son más fáciles de manipular y los desaconseja para eso.
- **Necesitas trabajo largo, desatendido y de muchos pasos.** Nuestros agentes locales necesitan un envoltorio que les insiste y comprueba el resultado. Lo contamos en los límites.

## Qué necesitas

- **Node.js 24.16.0 o posterior en la línea 24, o 26.1.0 o posterior.** La [página de Node](https://docs.openclaw.ai/install/node) de OpenClaw recomienda Node 26, y 24.22.1+ o 26.12.1+ por las correcciones de seguridad.
- **Ollama.** El [tutorial de Ollama](https://ollama.com/blog/openclaw-tutorial) del 23 de febrero de 2026 pide la 0.17 o posterior. Nuestras cifras salen de la 0.30.10 y la 0.34.0. Si empiezas de cero, lee antes [instalar Ollama y tu primer modelo](https://vorluxai.com/blog/instalar-ollama-primer-llm-local-es/).
- **Un modelo con la capacidad `tools`** y memoria para cargarlo con un contexto largo (paso 1).
- **macOS, Linux o Windows.** La [página de instalación](https://docs.openclaw.ai/install) ofrece un instalador de PowerShell y WSL2 para Windows. Nosotros solo lo hemos usado en Linux.
- **Docker**, si quieres el sandbox del paso 5.

## Paso 1: prepara el modelo en Ollama

El modelo de un agente tiene que devolver llamadas a herramientas bien formadas y aguantar un prompt largo.

```bash
ollama pull gemma4:26b
ollama show gemma4:26b     # "tools" debe aparecer en Capabilities
```

Después fija el contexto. La [página de longitud de contexto](https://docs.ollama.com/context-length) de Ollama (leída el 15 de noviembre de 2026) da el valor por defecto según la VRAM: 4k tokens por debajo de 24 GiB, 32k entre 24 y 48 GiB, 256k por encima. Recomienda al menos 64.000 tokens para agentes. La [página de configuración de Ollama](https://docs.openclaw.ai/providers/ollama/setup) de OpenClaw solo acepta un modelo con herramientas y al menos 16K de contexto.

Nosotros fijamos la ventana en una copia con nombre:

```bash
printf 'FROM gemma4:26b\nPARAMETER num_ctx 32768\n' > Modelfile
ollama create gemma4-32k -f Modelfile
ollama ps                  # la columna CONTEXT muestra lo cargado
```

El contexto cuesta memoria, y cuánta depende del modelo. Tamaños cargados según `ollama ps` en nuestras NVIDIA DGX Spark (GB10, 128 GB de memoria unificada), el 2 de noviembre de 2026 ([archivo de resultados](https://vorluxai.com/data/measurements/ollama-num-ctx-2026-11-02.json)):

| Modelo (Q4_K_M) | Contexto | Ranuras en paralelo | Cargado |
|---|---|---|---|
| `llama3.1:8b` | 32.768 | 1 | 9,21 GB |
| `llama3.1:8b` | 32.768 | 4 | 22,38 GB |
| `gemma4:26b` | 32.768 | 1 | 17,47 GB |
| `gemma4:26b` | 131.072 | 1 | 18,36 GB |

Nuestras máquinas tienen 128 GB, y no tenemos datos de un portátil ni de una tarjeta de consumo. Para dimensionar la tuya, usa [cuánta VRAM necesita un LLM local](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).

## Paso 2: instala OpenClaw y arranca la pasarela

**El lanzador.** La [página de integración de Ollama](https://docs.ollama.com/integrations/openclaw) documenta un solo comando:

```bash
ollama launch openclaw --model gemma4-32k
```

Según esa página, ofrece instalar OpenClaw con npm, muestra un aviso de seguridad, configura el proveedor, instala el servicio de la pasarela y abre la interfaz de terminal. También activa la búsqueda web de Ollama, que es un servicio alojado (mira los límites).

**A mano.** Estos comandos son de la [página de instalación](https://docs.openclaw.ai/install) de OpenClaw:

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon     # elige Ollama y después "Local only"
openclaw gateway status
```

**Qué deberías ver.** Esto es `openclaw gateway status` en nuestra pasarela el 15 de noviembre de 2026, recortado y con rutas y direcciones sustituidas:

```text
Service: systemd user (enabled)
Config (cli): ~/.openclaw/openclaw.json
CLI version: 2026.7.1-2
Gateway version: 2026.7.1-2
Runtime: running (pid <pid>, state active, sub running, last exit 0, reason 0)
Connectivity probe: ok
```

La pasarela escucha por defecto en el puerto 18789.

No hicimos una instalación nueva para esta guía: nuestra pasarela está en producción. Los pasos de instalación salen de la documentación de los dos fabricantes. La salida de arriba es nuestra.

## Paso 3: revisa la configuración del proveedor

Abre `~/.openclaw/openclaw.json`. El proveedor de Ollama debería tener esta forma, la de la [página de configuración](https://docs.openclaw.ai/providers/ollama/configuration) de OpenClaw:

```json5
{
  models: {
    providers: {
      ollama: {
        baseUrl: "http://127.0.0.1:11434",   // sin /v1
        apiKey: "ollama-local",              // marcador para hosts locales, no un secreto
        api: "ollama",
        timeoutSeconds: 300,                 // margen para una primera carga en frío
        models: [
          { id: "gemma4-32k", name: "gemma4-32k",
            contextTokens: 32768,
            params: { num_ctx: 32768, keep_alive: "15m" } }
        ]
      }
    }
  },
  agents: { defaults: { model: { primary: "ollama/gemma4-32k" } } }
}
```

Aquí importan tres cosas:

- **Sin `/v1`.** La [página del proveedor](https://docs.openclaw.ai/providers/ollama) dice que esa URL rompe las llamadas a herramientas, y que los modelos pueden imprimir el JSON de la llamada como texto. OpenClaw habla con el `/api/chat` nativo de Ollama.
- **`contextTokens` y `num_ctx` coinciden.** La [página avanzada](https://docs.openclaw.ai/providers/ollama/advanced) dice que `contextTokens` limita lo que envía OpenClaw y `params.num_ctx` fija lo que reserva Ollama. El descubrimiento local suele limitar `contextTokens` a 32.768.
- **Los modelos se nombran `ollama/<nombre>`.** Compruébalo con `openclaw models list`.

Nuestra pasarela usa dos tipos de proveedor: uno nativo `ollama` y otro compatible con OpenAI, que apunta a un router LiteLLM delante de nuestras dos máquinas. La documentación avisa de que en ese modo las llamadas a herramientas son menos fiables. Con una sola máquina, quédate en el nativo.

## Paso 4: conoce el espacio de trabajo y la memoria

OpenClaw separa dos cosas. `~/.openclaw/` guarda configuración, credenciales y sesiones. El espacio de trabajo, por defecto `~/.openclaw/workspace`, es el directorio donde trabaja el agente. Su memoria es Markdown plano en esa carpeta. La [página de memoria](https://docs.openclaw.ai/concepts/memory) dice que el modelo solo recuerda lo que se guarda en disco.

| Archivo | Para qué sirve |
|---|---|
| `AGENTS.md` | Instrucciones de funcionamiento, se cargan en cada sesión |
| `SOUL.md` | Personalidad, tono y límites |
| `USER.md` | Preferencias estables sobre ti |
| `MEMORY.md` | Hechos y decisiones a largo plazo |
| `memory/AAAA-MM-DD.md` | Notas diarias; las de hoy y ayer se cargan al abrir sesión |
| `TOOLS.md`, `IDENTITY.md` | Notas sobre herramientas locales y el nombre del agente |

Las descripciones siguen la [página del espacio de trabajo](https://docs.openclaw.ai/concepts/agent-workspace). El nuestro tiene los siete archivos y la carpeta `memory/`.

Un segundo agente recibe su propio espacio y su propio modelo:

```bash
openclaw agents add trabajo --workspace ~/.openclaw/workspace-trabajo --model ollama/gemma4-32k
openclaw agents list
```

Así tenemos nueve agentes, cada uno en una carpeta `workspace-<id>`. Una diferencia de versión: nuestra configuración 2026.7.1-2 guarda los agentes en `agents.list`, y la documentación de la 2026.11.3 escribe `agents.entries`. Deja que lo escriba la CLI.

La búsqueda en memoria necesita embeddings. La [página de búsqueda en memoria](https://docs.openclaw.ai/concepts/memory-search) dice que el proveedor por defecto es OpenAI y lista `ollama` y `local` como opciones sin clave de API. Elige una de esas si nada puede salir de la máquina.

## Paso 5: ciérralo antes de conectar nada

Estos son los valores por defecto en la documentación de la 2026.11.3:

| Área | Por defecto | Fuente |
|---|---|---|
| Escucha de la pasarela | solo loopback, con un token creado en la instalación | [Exposición de red](https://docs.openclaw.ai/gateway/security/network-exposure) |
| Remitente desconocido en un DM | recibe un código de emparejamiento, no una respuesta | [Seguridad](https://docs.openclaw.ai/gateway/security) |
| Sandbox | apagado | [Sandbox](https://docs.openclaw.ai/gateway/sandboxing) |
| Comandos de shell en el host | `security: full`, `ask: off` | [Aprobaciones de exec](https://docs.openclaw.ai/tools/exec-approvals) |
| Espacio de trabajo | el directorio por defecto, no una frontera | [Espacio de trabajo](https://docs.openclaw.ai/concepts/agent-workspace) |

Todo junto: por defecto, el agente puede ejecutar cualquier comando y leer cualquier archivo al alcance del usuario del sistema que corre la pasarela. Las rutas absolutas salen del espacio de trabajo.

**Qué hacer, de lo más barato a lo más caro:**

1. **Dale su propio usuario o una máquina virtual pequeña.** El tutorial de Ollama pide ejecutar OpenClaw en un entorno aislado. Así el alcance del agente es el de ese usuario.
2. **Enciende el sandbox.** Mueve la ejecución de herramientas a un contenedor Docker. La documentación dice que no es una frontera perfecta, pero limita el acceso a archivos y procesos.
3. **Restringe las herramientas.** Deniega lo que el agente no necesita y haz que los comandos de shell pidan permiso.
4. **Pasa la auditoría.** `openclaw security audit` revisa la configuración y el estado en busca de errores habituales. `--fix` cambia archivos, así que lee antes el informe.

Un punto de partida, montado con la [base endurecida](https://docs.openclaw.ai/gateway/security/hardened-baseline) y los [modos del sandbox](https://docs.openclaw.ai/gateway/sandboxing/modes-scope-and-backend):

```json5
{
  gateway: { bind: "loopback", auth: { mode: "token" } },
  agents: { defaults: { sandbox: { mode: "all", workspaceAccess: "none" } } },
  tools: {
    fs: { workspaceOnly: true },
    exec: { security: "allowlist", ask: "on-miss" },
    elevated: { enabled: false }
  },
  channels: { telegram: { dmPolicy: "pairing", groups: { "*": { requireMention: true } } } }
}
```

`workspaceAccess` admite `none`, `ro` o `rw`. La página de aprobaciones llama a `security` y `ask` una pareja heredada que `openclaw doctor` migra a `tools.exec.mode`. Comprueba el resultado con `openclaw sandbox explain`. Este bloque lo montamos con la documentación y no lo hemos aplicado a nuestra pasarela de producción para esta guía.

**Qué no exponer nunca a la red:**

- **El puerto 18789.** La página de exposición de red dice que nunca expongas la pasarela sin autenticación en `0.0.0.0`. Para el acceso remoto prefiere Tailscale Serve, que la mantiene en loopback.
- **El puerto 11434 de Ollama.** Las [preguntas frecuentes](https://docs.ollama.com/faq) de Ollama dicen que por defecto escucha en `127.0.0.1`. Déjalo así.
- **`~/.openclaw/`.** Guarda credenciales y sesiones de los canales. Sus copias de seguridad, también.

Un modelo local no elimina el riesgo de inyección. Cualquier página, correo o archivo que lea el agente puede traer instrucciones. Ensaya con [el correo que da órdenes](https://vorluxai.com/playground/prompt-injection/) y [el documento envenenado](https://vorluxai.com/playground/indirect-injection-rag/).

## Paso 6: conecta un canal

Telegram es el camino más corto, porque solo necesita un token de bot. De la [página de Telegram](https://docs.openclaw.ai/channels/telegram/setup): crea un bot con `@BotFather` y después:

```bash
openclaw channels add --channel telegram --token <token-del-bot>
openclaw channels status --probe
# escribe cualquier mensaje a tu bot y después:
openclaw pairing list telegram
openclaw pairing approve telegram <CÓDIGO>
```

La página dice que los códigos caducan a la hora. Los cuatro comandos existen en la 2026.7.1-2. No los hemos ejecutado: nuestra pasarela tiene un canal, WhatsApp, enlazado con `openclaw channels login --channel whatsapp`.

El transporte no es privado. Los mensajes pasan por los servidores de Telegram o de WhatsApp aunque el modelo sea local.

## Paso 7: programa una tarea

```bash
openclaw cron add --name "Resumen matinal de notas" \
  --cron "0 8 * * 1-5" --tz "Europe/Madrid" \
  --session isolated --model ollama/gemma4-32k \
  --message "Lee los archivos de notas/ modificados en las últimas 24 horas. Responde con tres viñetas y una acción para hoy." \
  --announce --channel telegram --to <id-del-chat> \
  --disabled
openclaw cron list --all
openclaw cron run <id-de-la-tarea> --wait     # después: openclaw cron runs --id <id-de-la-tarea>
openclaw cron enable <id-de-la-tarea>
```

Todas las opciones están en el `--help` de la 2026.7.1-2 y en la [referencia de cron](https://docs.openclaw.ai/cli/cron). No hemos creado esta tarea en nuestra pasarela.

Dos cosas que hemos aprendido con 17 tareas ([archivo de huella](https://vorluxai.com/data/measurements/openclaw-gateway-footprint-2026-11-15.json)):

- **No todas las tareas necesitan un modelo.** `--command "<shell>"` ejecuta un script en la pasarela, sin turno de agente. Nuestras comprobaciones de salud son tareas de comando: decide un script, y al chat solo llega algo cuando hay un cambio.
- **Lee la ejecución, no el estado.** La [página de problemas](https://docs.openclaw.ai/automation/cron-jobs/troubleshooting) dice que una ejecución puede acabar en `ok` después de que fallara una llamada a exec y el agente respondiera. Nosotros comprobamos que cada agente dejó una nota fechada en `memory/` y cambió el archivo que tenía que cambiar.

Una diferencia de nombre: la documentación de la 2026.11.3 llama a esto "automations" y acepta las dos formas. En la 2026.7.1-2 solo existe `openclaw cron`.

## Paso 8: actualiza sin perder el estado

Nuestra pasarela está en la 2026.7.1-2, y `openclaw update status` anunciaba la 2026.11.3 el 15 de noviembre de 2026. El orden de abajo es el de la [página de vuelta atrás y recuperación](https://docs.openclaw.ai/install/updating/rollback-and-recovery). `backup create` y `update --dry-run` existen en nuestra versión.

```bash
openclaw backup create --output ~/Backups/openclaw --verify
openclaw update --dry-run
openclaw update
openclaw doctor
```

La misma página avisa de que bajar de versión el paquete no deshace las migraciones de configuración ni de base de datos. El camino de vuelta soportado es la copia verificada con su versión correspondiente. Guarda ese archivo en privado: puede contener credenciales.

Nosotros no hemos dado este salto. Cruza cuatro meses de versiones, y la documentación describe migraciones: los monitores de heartbeat pasan a ser tareas programadas, y las aprobaciones de exec, de un archivo JSON a una base de datos. Lee antes las [notas de versión](https://github.com/openclaw/openclaw/releases).

## Qué puede y qué no puede hacer un modelo local como cerebro

**Llamadas a herramientas: la forma está bien, el criterio depende del tamaño.** El 15 de noviembre de 2026 enviamos seis peticiones a cada uno de dos modelos, con tres herramientas como las de un agente (`Read`, `Bash`, `Grep`). Temperatura 0, una ejecución por caso, comprobado por script ([archivo de resultados](https://vorluxai.com/data/measurements/ollama-anthropic-messages-probe-2026-11-15.json)).

| | `llama3.1:8b` | `gemma4:26b` (32k) |
|---|---|---|
| Llamadas bien formadas | todas | todas |
| Casos superados | 4 de 6 | 5 de 6 |
| "Responde con tres palabras exactas" | llamó a `Bash` con `echo` | texto |
| "¿Qué significa JSON?" | llamó a `Bash` con `echo` | texto |

El modelo de 8B tiró de la shell cuando no hacía falta ninguna herramienta. En un agente con exec en el host, cada una de esas es un comando que no pediste. El único fallo del 26B fue listar los archivos de test antes de ejecutarlos.

Esta prueba usó el endpoint de Ollama compatible con Anthropic y un prompt de sistema corto. OpenClaw usa `/api/chat` y envía un prompt mucho más largo, con más herramientas. Tómala como un suelo. El método completo está en [Claude Code con un modelo local de Ollama](https://vorluxai.com/blog/claude-code-local-models-ollama-web-search-subagents-es/).

**La salida estructurada apunta en la misma dirección.** En nuestra prueba con 40 facturas españolas del 5 de noviembre de 2026, `gemma4:26b` acertó todos los campos en las 40. `qwen2.5-coder:7b` llegó al 85 % y `llama3.1:8b` al 62,5 % ([archivo de resultados](https://vorluxai.com/data/measurements/structured-extraction-2026-11-05.json)).

**Contexto: el desbordamiento puede ser silencioso.** En la misma prueba enviamos un prompt de 64.507 caracteres a un modelo cargado con 6.144 tokens. Ollama devolvió HTTP 200, contó 3.070 tokens de entrada, y el modelo dijo que no veía ninguna palabra clave. La palabra estaba en la primera línea. La página avanzada de OpenClaw dice que sus peticiones nativas llevan ahora `truncate: false`, de modo que un servidor compatible rechaza el exceso, y OpenClaw compacta y reintenta. La página lo da por verificado con Ollama 0.33.3. Nosotros no lo hemos probado, y no sabemos si la 2026.7.1-2 se comporta así.

**Tareas largas: el turno acaba cuando el modelo escribe texto.** Nuestros agentes locales tienden a describir el trabajo tras unas pocas llamadas a herramientas, y ahí se acaba el turno. Los ejecutamos con un envoltorio que insiste hasta que cambia un archivo o el agente escribe por qué para. No tenemos archivo de resultados de esto, así que tómalo como experiencia nuestra y no como medición.

## Qué medimos: la propia pasarela

Una muestra de solo lectura de nuestra pasarela de producción en una NVIDIA DGX Spark (GB10, 128 GB de memoria unificada), el 15 de noviembre de 2026 ([archivo de resultados](https://vorluxai.com/data/measurements/openclaw-gateway-footprint-2026-11-15.json)):

| Elemento | Valor |
|---|---|
| Versión | OpenClaw 2026.7.1-2 |
| Proceso de la pasarela, memoria residente | 529.652 kB (unos 0,53 GB) |
| Mismo proceso, pico desde el arranque | 1.181.328 kB (unos 1,18 GB) |
| Memoria del servicio (systemd), actual y pico | 0,62 GB y 1,39 GB |
| Agentes, tareas programadas, canales | 9, 17, 1 |

Llevaba unas 35 horas encendida y estaba en reposo entre tareas. La memoria del modelo va aparte. Una versión anterior de este artículo citaba cifras de septiembre de 2026 sin archivo de resultados. Las hemos retirado.

## Fallos que te vas a encontrar

**1. Las llamadas a herramientas llegan como texto.** La URL del proveedor acaba en `/v1`, o el modelo no maneja los esquemas de herramientas. Usa la URL nativa con `api: "ollama"`. Si un modelo pequeño sigue fallando, la [página de problemas](https://docs.openclaw.ai/providers/ollama/troubleshooting) propone `compat.supportsTools: false` en su entrada.

**2. La primera respuesta agota el tiempo.** El modelo se está cargando desde disco. En nuestra prueba de contexto, `gemma4:26b` tardó 32 segundos en la primera carga y entre 9 y 10 en las dos siguientes. Ajusta `timeoutSeconds` y `keep_alive` como en el paso 3.

**3. `Unknown command: openclaw automations`.** Nos salió en la 2026.7.1-2 al teclear un comando de la documentación actual. Las instalaciones antiguas solo tienen `openclaw cron`.

**4. El servicio se queja de Node.** Nuestro `gateway status` imprime `Gateway service uses Node from a version manager; it can break after upgrades.` Instalamos Node con nvm. El mensaje recomienda `openclaw doctor`.

**5. La tarea corrió y no llegó nada.** La página de problemas de cron lista un `channel` o un `to` ausente o inválido, el modo de entrega `none` y los errores de autenticación del canal. Empieza por `openclaw cron runs --id <id-de-la-tarea>`.

**6. Reinicios en bucle en WSL2 con una GPU NVIDIA.** La página de problemas de Ollama en OpenClaw describe cómo el servicio de Ollama recarga un modelo al arrancar hasta que Windows detiene la máquina virtual. Su remedio es `sudo systemctl disable ollama`. Nosotros no usamos WSL2.

## Límites y qué no hemos probado

- **La búsqueda web no es local.** La [página de búsqueda web](https://docs.openclaw.ai/providers/ollama/web-search) de OpenClaw dice que un host local debe haber iniciado sesión con `ollama signin`. Déjala apagada en un montaje estrictamente local.
- **Sin filtro de seguridad alojado.** La [página de modelos locales](https://docs.openclaw.ai/gateway/local-models) dice que los modelos locales no traen los filtros de los proveedores alojados.

**No lo hemos probado:** una instalación nueva con la versión de hoy, la propia 2026.11.3, el bloque de seguridad del paso 5, Telegram, el sandbox, macOS, Windows, ni ninguna máquina más pequeña que las nuestras.

## Preguntas frecuentes

**¿OpenClaw funciona sin conexión?** La pasarela y un modelo local, sí. Los canales de chat, la búsqueda web y las actualizaciones necesitan red.

**¿Bastan 32k si Ollama recomienda 64k?** A nosotros nos funciona con tareas cortas. Las sesiones largas se compactan antes. Si tienes memoria, usa 64k.

**¿OpenClaw o n8n?** n8n ejecuta pasos fijos que has dibujado tú. OpenClaw deja que un modelo decida los pasos. Para un pipeline que debe hacer lo mismo cada día, usa [n8n](https://vorluxai.com/blog/tutorial-n8n-pipeline-contenido-ia/).

## Siguientes pasos

- Dimensiona la memoria: [cuánta VRAM necesita un LLM local](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).
- Mira el contexto frente a la memoria, modelo a modelo: [num_ctx de Ollama, medido](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/).

## Trabaja con nosotros

Tenemos nueve agentes en una pasarela OpenClaw sobre nuestro propio hardware, y sabemos dónde se quedan cortos los modelos locales. Si quieres un primer agente en tu oficina, cerrado y a la medida de tu máquina, [escríbenos](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
