---
title: "Guia de Despliegue de NullClaw: La Infraestructura de Asistente IA Mas Pequeña en Zig"
description: "Guia paso a paso para desplegar NullClaw en un VPS Linux. Cubre binario Zig, 22+ proveedores LLM, 17 canales de chat, memoria hibrida, sandboxing y ejecucion en hardware de $5."
date: 2026-02-22
categories: ["AI"]
tags: ["ai-tools","self-hosted","vps","zig"]
---

import YouTubeEmbed from "@components/widgets/YouTubeEmbed.astro";
import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
import Tabs from "@components/widgets/Tabs.astro";
import Tab from "@components/widgets/Tab.astro";

[NullClaw](https://github.com/nullclaw/nullclaw) es el asistente de IA mas pequeño que he encontrado que todavia hace todo. Un unico binario estatico de 678 KB escrito en Zig, aproximadamente 1 MB de RAM en ejecucion. Sin runtime, sin VM, sin overhead de framework. Arranca en menos de 2 milisegundos y corre en cualquier cosa que tenga CPU, incluyendo placas ARM de $5.

Esta guia te lleva paso a paso para desplegar NullClaw en un VPS con tu eleccion de proveedor LLM, canales de chat, memoria hibrida y sandboxing adecuado.

<Button text="NullClaw en GitHub" link="https://github.com/nullclaw/nullclaw" variant="solid" color="purple" size="md" icon="github" />

<Notice type="info" title="Lo que cubre esta guia">
<ListCheck>
<ul>
<li>Compilar NullClaw desde el codigo fuente o usando Docker</li>
<li>Configurar 22+ proveedores LLM via endpoints compatibles con OpenAI</li>
<li>Configurar Telegram, Discord, Slack u otros 10 canales</li>
<li>Sistema de memoria hibrida con SQLite FTS5 + busqueda vectorial</li>
<li>Sandboxing multi-capa (Landlock, Firejail, Bubblewrap, Docker)</li>
<li>Integracion con servidores MCP</li>
<li>Ejecucion en hardware edge y placas de $5</li>
</ul>
</ListCheck>
</Notice>

Si estas comparando opciones de bots auto-alojados, nuestro articulo de [alternativas a OpenClaw](/es/alternativas-openclaw/) incluye NullClaw junto con ZeroClaw, nanobot, [NanoClaw](/es/guia-despliegue-nanoclaw/) y PicoClaw.


## Que es NullClaw realmente

NullClaw es un asistente de IA escrito completamente en Zig. El eslogan es "null overhead, null compromise" — un binario estatico con cero dependencias de runtime que corre en el hardware mas barato que puedas encontrar.

La arquitectura usa interfaces vtable para cada subsistema. ¿Quieres cambiar tu proveedor LLM? Cambia una linea de configuracion. Lo mismo para canales, backends de memoria, herramientas, tuneles, sandboxes y perifericos.

```
678 KB binary · <2 ms startup · 3,230+ tests · 22+ providers · 17 channels · Pluggable everything
```

### Como se compara

| | [OpenClaw](https://github.com/openclaw/openclaw) | [nanobot](https://github.com/HKUDS/nanobot) | [ZeroClaw](https://github.com/zeroclaw-labs/zeroclaw) | **[NullClaw](https://github.com/nullclaw/nullclaw)** |
|---|---|---|---|---|
| **Lenguaje** | TypeScript | Python | Rust | **Zig** |
| **RAM** | > 1 GB | > 100 MB | < 5 MB | **~1 MB** |
| **Arranque** | > 500 s | > 30 s | < 10 ms | **< 2 ms** |
| **Binario** | ~28 MB | N/A | 3.4 MB | **678 KB** |
| **Tests** | — | — | 1,017 | **3,230+** |
| **Canales** | 4 | 9 | 8+ | **17** |
| **Proveedores** | Varios | 13+ | 22+ | **22+** |
| **Hardware minimo** | Mac Mini $599 | Linux SBC ~$50 | Cualquier hardware de $10 | **Cualquier hardware de $5** |

Los numeros de benchmark se miden en hardware edge de 0.8 GHz. NullClaw arranca en menos de 8 milisegundos incluso en los targets mas lentos.

## Por que Zig

Zig es un lenguaje de programacion de sistemas que compila a rendimiento tipo C con cero overhead de runtime:

| Propiedad | Que significa para NullClaw |
|----------|---------------------------|
| Sin recolector de basura | Memoria deterministica, sin pausas |
| Sin asignaciones ocultas | Tu controlas cada byte |
| Binario estatico | Sin dependencias, soltar y ejecutar |
| Ejecucion en tiempo de compilacion | Validacion de config en tiempo de build |
| Compilacion cruzada | Compilar para ARM desde x86 |

Ese binario de 678 KB cubre el mismo conjunto de funciones que alternativas que pesan multiples gigabytes.

## Instalacion

Dos formas principales de instalar NullClaw.

<Tabs>
<Tab name="Desde el codigo fuente (recomendado)">

Necesitas Zig 0.15.2 (version exacta requerida):

```bash
# Install Zig (Linux)
curl -L https://ziglang.org/download/0.15.2/zig-linux-x86_64-0.15.2.tar.xz | tar -xJ
sudo mv zig-linux-x86_64-0.15.2 /usr/local/zig
sudo ln -s /usr/local/zig/zig /usr/local/bin/zig

# Clone and build
git clone https://github.com/nullclaw/nullclaw.git
cd nullclaw

# Release build (678 KB)
zig build -Doptimize=ReleaseSmall

# The binary is at zig-out/bin/nullclaw
ls -lh zig-out/bin/nullclaw
```

</Tab>
<Tab name="Docker">

Si prefieres contenedores:

```bash
# Build the image
docker build -t nullclaw .

# Run
docker run -d \
  -v ~/.nullclaw:/root/.nullclaw \
  -p 3000:3000 \
  --name nullclaw \
  nullclaw
```

</Tab>
</Tabs>

Despues de compilar, ejecuta el asistente de configuracion:

```bash
# Quick setup (non-interactive)
nullclaw onboard --api-key sk-... --provider openrouter

# Or interactive wizard
nullclaw onboard --interactive
```

Esto crea `~/.nullclaw/` con un `config.json` y una carpeta de workspace.

Verifica que todo funciona:

```bash
nullclaw status
```

## Configurar proveedores LLM

NullClaw soporta 22+ proveedores de fabrica. Cada proveedor usa la interfaz compatible con OpenAI, asi que cambiar es solo un cambio de configuracion.

### Proveedores soportados

| Proveedor | Caso de uso |
|----------|----------|
| OpenRouter | Gateway a cualquier modelo |
| Anthropic | Modelos Claude |
| OpenAI | Modelos GPT |
| Ollama | Modelos locales |
| Venice | Enfocado en privacidad |
| Groq | Inferencia rapida |
| Mistral | Modelos Mistral |
| xAI | Modelos Grok |
| DeepSeek | Modelos DeepSeek |
| Together | Modelos open-source |
| Fireworks | Open-source rapido |
| Perplexity | Aumentado con busqueda |
| Cohere | Modelos Command |
| Bedrock | Modelos hosteados en AWS |
| Gemini | Google Gemini |
| Custom | Cualquier endpoint compatible con OpenAI |

### Obtener una clave API

Para OpenRouter (recomendado por flexibilidad):

1. Ve a [openrouter.ai](https://openrouter.ai)
2. Crea una cuenta y genera una clave API
3. La clave empieza con `sk-or-`

<Notice type="success" title="Plan de codificacion MiniMax — 10% de descuento">
Si quieres usar MiniMax M2.5 o GLM-5 a traves de OpenRouter, revisa nuestros [enlaces de referido](/es/mejores-modelos-opensource-openclaw/) para descuentos en planes de codificacion.
</Notice>

### Agregar a la configuracion

Edita `~/.nullclaw/config.json`:

```json
{
  "default_provider": "openrouter",
  "default_temperature": 0.7,
  "models": {
    "providers": {
      "openrouter": {
        "api_key": "sk-or-your-key"
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-sonnet-4"
      }
    }
  }
}
```

### Usar proveedores personalizados

Cualquier endpoint compatible con OpenAI funciona:

```json
{
  "models": {
    "providers": {
      "minimax": {
        "api_key": "your-minimax-key",
        "base_url": "https://api.minimax.chat/v1"
      }
    }
  }
}
```

Luego configura `"default_provider": "minimax"`.

### Modelos recomendados

Si buscas modelos rentables para emparejar con NullClaw, dos opciones open-source funcionan bien:

**[MiniMax M2.5](/es/mejores-modelos-opensource-openclaw/)** — Un modelo MoE de 230B con 10B parametros activos. Obtiene 80.2% en SWE-Bench Verified a una fraccion del costo de Claude ($0.15/M tokens de entrada). La variante Lightning corre a 100 tokens/seg. Disponible a traves de OpenRouter o directamente via la [API de MiniMax](https://go.bitdoze.com/minimax).

**[GLM-5](/es/mejores-modelos-opensource-openclaw/)** — Un modelo MoE de 744B de Z.AI con 40B parametros activos. 95.8% en SWE-bench Verified y casi cero alucinaciones. Disponible a traves de OpenRouter o [planes de codificacion Z.AI](https://z.ai/subscribe?ic=NKNUNYDRZT).

Ambos se cubren en detalle en nuestra [guia de configuracion de nanobot](/es/guia-configuracion-nanobot/), que explica la configuracion de claves API y proveedores. Los mismos modelos funcionan con NullClaw a traves de OpenRouter o endpoints directos del proveedor.

### Probar

```bash
nullclaw agent -m "What's 42 * 17?"
```

## Configuracion de canales

NullClaw soporta 17 canales de chat. Elige el que uses.

### Telegram

1. Crea un bot via [@BotFather](https://t.me/BotFather)
2. Copia el token del bot
3. Obtén tu ID de usuario de Telegram (envia mensaje a [@userinfobot](https://t.me/userinfobot))

Configuracion:

```json
{
  "channels": {
    "telegram": {
      "accounts": {
        "main": {
          "bot_token": "123456789:ABCdefGHIjklMNOpqrSTUvwxYZ",
          "allow_from": ["your_telegram_user_id"],
          "reply_in_private": true
        }
      }
    }
  }
}
```

<Notice type="warning" title="Comportamiento de la lista de permitidos">
`allow_from` vacio significa **denegar todos**. Usa `["*"]` para permitir a todos, o agrega IDs de usuario especificos para restringir el acceso.
</Notice>

### Discord

1. Ve a [discord.com/developers/applications](https://discord.com/developers/applications)
2. Crea un bot y copia el token
3. Habilita **MESSAGE CONTENT INTENT** en la configuracion del Bot

Configuracion:

```json
{
  "channels": {
    "discord": {
      "accounts": {
        "main": {
          "token": "your-discord-bot-token",
          "guild_id": "your-server-id",
          "allow_from": ["your_user_id"],
          "allow_bots": false
        }
      }
    }
  }
}
```

### Slack

Configuracion:

```json
{
  "channels": {
    "slack": {
      "accounts": {
        "main": {
          "bot_token": "xoxb-your-bot-token",
          "app_token": "xapp-your-app-token",
          "allow_from": ["U1234567890"]
        }
      }
    }
  }
}
```

### Otros canales

| Canal | Clave de config | Notas |
|---------|-----------|-------|
| iMessage | `imessage` | Solo macOS |
| Matrix | `matrix` | Requiere homeserver |
| WhatsApp | `whatsapp` | Via webhook de Meta |
| Signal | `signal` | Requiere Signal-cli |
| Line | `line` | LINE Messaging API |
| Webhook | `webhook` | Endpoint HTTP personalizado |
| IRC | `irc` | Libera, OFTC, etc. |
| Lark/Feishu | `lark` | Espacio de trabajo ByteDance |
| DingTalk | `dingtalk` | Espacio de trabajo Alibaba |
| QQ | `qq` | Via go-cqhttp |
| OneBot | `onebot` | Protocolo universal de bots |
| Email | `email` | IMAP/SMTP |
| MaixCam | `maixcam` | Hardware Sipeed |

## Ejemplo de configuracion completa

Aqui tienes un `~/.nullclaw/config.json` completo con OpenRouter, Telegram, memoria hibrida y sandboxing:

```json
{
  "default_provider": "openrouter",
  "default_temperature": 0.7,

  "models": {
    "providers": {
      "openrouter": { "api_key": "sk-or-..." }
    }
  },

  "agents": {
    "defaults": {
      "model": { "primary": "anthropic/claude-sonnet-4" },
      "heartbeat": { "every": "30m" }
    }
  },

  "channels": {
    "telegram": {
      "accounts": {
        "main": {
          "bot_token": "123:ABC",
          "allow_from": ["your_user_id"]
        }
      }
    }
  },

  "memory": {
    "backend": "sqlite",
    "auto_save": true,
    "embedding_provider": "openai",
    "vector_weight": 0.7,
    "keyword_weight": 0.3,
    "hygiene_enabled": true
  },

  "gateway": {
    "port": 3000,
    "require_pairing": true,
    "allow_public_bind": false
  },

  "autonomy": {
    "level": "supervised",
    "workspace_only": true,
    "max_actions_per_hour": 20
  },

  "runtime": {
    "kind": "native",
    "docker": {
      "image": "alpine:3.20",
      "network": "none",
      "memory_limit_mb": 512,
      "read_only_rootfs": true
    }
  },

  "security": {
    "sandbox": { "backend": "auto" },
    "resources": { "max_memory_mb": 512, "max_cpu_percent": 80 },
    "audit": { "enabled": true, "retention_days": 90 }
  },

  "tunnel": { "provider": "none" },
  "secrets": { "encrypt": true },
  "identity": { "format": "openclaw" }
}
```

## Sistema de memoria

La memoria de NullClaw esta construida sobre SQLite sin dependencias externas:

| Capa | Implementacion |
|-------|---------------|
| **Vector DB** | Embeddings almacenados como BLOB, busqueda por similitud coseno |
| **Busqueda por palabras clave** | Tablas virtuales FTS5 con puntuacion BM25 |
| **Fusion hibrida** | Pesos configurables vector/palabras clave |
| **Embeddings** | OpenAI, URL personalizada, o noop |
| **Higiene** | Archivado automatico + purga de memorias obsoletas |
| **Snapshots** | Exportar/importar para migracion |

Configuracion:

```json
{
  "memory": {
    "backend": "sqlite",
    "auto_save": true,
    "embedding_provider": "openai",
    "vector_weight": 0.7,
    "keyword_weight": 0.3,
    "hygiene_enabled": true
  }
}
```

Configura `embedding_provider` a `noop` si no quieres pagar por embeddings. La busqueda por palabras clave FTS5 sigue funcionando.

### Archivos de identidad

NullClaw soporta dos formatos de identidad:

| Formato | Archivos | Caso de uso |
|--------|-------|----------|
| `openclaw` | `IDENTITY.md`, `SOUL.md`, `USER.md` | Basado en Markdown |
| `aieos` | Un solo archivo JSON | Personas de IA portables |

Edita estos en `~/.nullclaw/workspace/` para personalizar la personalidad del bot y su conocimiento sobre ti.

## Modelo de seguridad

NullClaw bloquea las cosas en multiples niveles, no solo listas de permitidos a nivel de aplicacion.

### Seguridad del gateway

| Capa | Por defecto | Que hace |
|-------|---------|-------------|
| Vinculacion a localhost | `127.0.0.1` | Rechaza exposicion publica |
| Emparejamiento requerido | `true` | Intercambio de codigo de 6 digitos por bearer token |
| Tunel requerido | `false` | Rechaza `0.0.0.0` sin tunel |

Para exponer el gateway, configura un tunel:

```json
{
  "tunnel": {
    "provider": "cloudflare"
  }
}
```

Tuneles soportados: Cloudflare, Tailscale, ngrok o binario personalizado.

### Aislamiento con sandbox

NullClaw auto-detecta el mejor backend de sandbox:

| Backend | Plataforma | Nivel de seguridad |
|---------|----------|---------------|
| Landlock | Linux 5.13+ | Nivel de kernel |
| Firejail | Linux | Namespaces |
| Bubblewrap | Linux | Contenedores ligeros |
| Docker | Cualquiera | Aislamiento completo por contenedor |

Configuracion:

```json
{
  "security": {
    "sandbox": { "backend": "auto" }
  }
}
```

Configura `"backend": "docker"` para maximo aislamiento.

### Secretos encriptados

Las claves API se encriptan con ChaCha20-Poly1305:

```json
{
  "secrets": { "encrypt": true }
}
```

La clave de encriptacion se almacena localmente en `~/.nullclaw/`.

### Alcance del workspace

Con `workspace_only = true`, el bot solo puede acceder a archivos dentro de su workspace. Los intentos de escape via symlink se bloquean mediante canonicalizacion de rutas.

## Soporte MCP

NullClaw soporta servidores de Model Context Protocol:

```json
{
  "mcp_servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/documents"]
    }
  }
}
```

Las herramientas MCP se descubren y registran automaticamente. El bot puede usarlas junto con las herramientas integradas.

## Tareas programadas

NullClaw tiene un programador cron integrado:

```bash
# List scheduled tasks
nullclaw cron list

# Add a recurring task
nullclaw cron add --name "morning" --message "What's on my calendar today?" --cron "0 9 * * *"

# Run a task once
nullclaw cron run <task_id>

# Pause/resume
nullclaw cron pause <task_id>
nullclaw cron resume <task_id>
```

Las tareas se persisten en JSON y sobreviven a reinicios.

## Referencia del CLI

| Comando | Descripcion |
|---------|-------------|
| `nullclaw onboard --api-key sk-...` | Configuracion rapida |
| `nullclaw onboard --interactive` | Asistente completo |
| `nullclaw agent -m "..."` | Mensaje unico |
| `nullclaw agent` | Chat interactivo |
| `nullclaw gateway` | Iniciar servidor webhook |
| `nullclaw daemon` | Runtime autonomo completo |
| `nullclaw status` | Estado del sistema |
| `nullclaw doctor` | Diagnosticos |
| `nullclaw channel doctor` | Salud del canal |
| `nullclaw service install` | Instalar como servicio del sistema |
| `nullclaw cron list/add/remove` | Gestionar tareas programadas |
| `nullclaw skills list/install` | Gestionar packs de habilidades |
| `nullclaw hardware scan` | Detectar perifericos |
| `nullclaw migrate openclaw` | Importar desde OpenClaw |

## Despliegue en VPS

Para uso en produccion, aqui tienes una configuracion completa de VPS.

### Requisitos del servidor

| Especificacion | Minimo | Funciona con |
|------|---------|------------|
| CPU | Cualquiera | Core edge de 0.8 GHz |
| RAM | 256 MB | 1 GB+ recomendado |
| Almacenamiento | 1 GB | 10 GB para logs |
| OS | Linux | Ubuntu 22.04+ |

NullClaw corre en placas de $5. Lo probe en una Raspberry Pi Zero 2 W y funciono sin problemas.

### Despliegue rapido

```bash
ssh root@YOUR_SERVER_IP

# Update system
apt update && apt upgrade -y

# Install Zig
curl -L https://ziglang.org/download/0.15.2/zig-linux-x86_64-0.15.2.tar.xz | tar -xJ
sudo mv zig-linux-x86_64-0.15.2 /usr/local/zig
sudo ln -s /usr/local/zig/zig /usr/local/bin/zig

# Clone and build
git clone https://github.com/nullclaw/nullclaw.git
cd nullclaw
zig build -Doptimize=ReleaseSmall

# Install binary
sudo cp zig-out/bin/nullclaw /usr/local/bin/

# Initialize
nullclaw onboard --interactive

# Edit config
nano ~/.nullclaw/config.json

# Start daemon
nullclaw daemon
```

### Servicio systemd

Para inicio automatico:

```bash
nullclaw service install
nullclaw service start
nullclaw service status
```

O crealo manualmente:

```ini
[Unit]
Description=NullClaw AI Assistant
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/nullclaw daemon
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
```

Guarda en `/etc/systemd/system/nullclaw.service`, luego:

```bash
systemctl daemon-reload
systemctl enable nullclaw
systemctl start nullclaw
```

### Ejecucion en hardware edge

El bajo consumo de recursos de NullClaw lo hace ideal para despliegue edge:

| Hardware | RAM | Estado |
|----------|-----|--------|
| Raspberry Pi Zero 2 W | 512 MB | ✅ Funciona |
| Raspberry Pi 4 | 2-8 GB | ✅ Funciona |
| Orange Pi Zero | 256 MB | ✅ Funciona |
| SBC de $5 en AliExpress | 256 MB | ✅ Funciona |
| MaixCam (RISC-V) | 256 MB | ✅ Soportado |

Compilar para ARM desde x86:

```bash
zig build -Dtarget=aarch64-linux -Doptimize=ReleaseSmall
```

## API del Gateway

| Endpoint | Metodo | Auth | Descripcion |
|----------|--------|------|-------------|
| `/health` | GET | Ninguna | Chequeo de salud |
| `/pair` | POST | `X-Pairing-Code` | Intercambiar codigo por token |
| `/webhook` | POST | Bearer token | Enviar mensaje |
| `/whatsapp` | GET | Parametros de query | Verificacion de webhook de Meta |
| `/whatsapp` | POST | Firma de Meta | WhatsApp entrante |

Flujo de emparejamiento:

```bash
# Start gateway (shows pairing code)
nullclaw gateway

# Exchange code for token
curl -X POST http://127.0.0.1:3000/pair \
  -H "X-Pairing-Code: 123456"

# Use token for requests
curl -X POST http://127.0.0.1:3000/webhook \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello, nullclaw!"}'
```

## NullClaw vs ZeroClaw vs nanobot

Uso los tres, asi que aqui va una comparacion directa:

| Aspecto | NullClaw 🟠 | ZeroClaw 🦀 | nanobot 🐍 |
|--------|------------|------------|-----------|
| Lenguaje | Zig | Rust | Python |
| Uso de RAM | ~1 MB | < 5 MB | ~100 MB |
| Arranque | < 2 ms | < 10 ms | > 2 s |
| Tamaño del binario | 678 KB | 3.4 MB | N/A |
| Cantidad de canales | 17 | 8+ | 9 |
| Cantidad de proveedores | 22+ | 22+ | 13+ |
| Memoria | Hibrida SQLite | Hibrida SQLite | Basada en archivos |
| Seguridad | Sandbox + emparejamiento | Emparejamiento + sandbox | Listas de permitidos |
| Hardware minimo | Placa de $5 | Placa de $10 | SBC de $50 |
| Metodo de instalacion | `zig build` | `cargo install` | `pip install` |

NullClaw es la opcion mas ligera aqui. ZeroClaw es mas facil de configurar si ya estas en el ecosistema Rust. nanobot tiene el soporte de canales mas amplio.

<Accordion label="Preguntas frecuentes" group="faq" expanded="true">

**¿Cuanto cuesta ejecutar NullClaw?**

Hardware: $5 por una placa ARM barata, o $0 si ya tienes un VPS de [Hetzner](https://go.bitdoze.com/hetzner) o [Hostinger](https://go.bitdoze.com/hostinger-vps). Los costos de API dependen de tu proveedor — espera $5-50/mes para uso personal.

**¿Puedo ejecutar NullClaw sin costos de API?**

Si. Configura Ollama como tu proveedor y apuntalo a un modelo local. Necesitas hardware que pueda ejecutar inferencia, pero no hay facturas de API.

**¿NullClaw funciona en una Raspberry Pi Zero?**

Si. La Pi Zero 2 W de 512 MB ejecuta NullClaw sin problemas. La Pi Zero original (un solo nucleo) podria tener dificultades con la inferencia pero el asistente en si funciona.

**¿Pueden varias personas usar una instancia de NullClaw?**

Si. Agrega multiples IDs de usuario a `allow_from`. Cada persona obtiene su propio contexto de conversacion.

**¿Cual es la diferencia entre gateway y daemon?**

`nullclaw gateway` inicia solo el servidor webhook. `nullclaw daemon` inicia el runtime autonomo completo incluyendo todos los canales, tareas de heartbeat y el programador.

**¿Puedo migrar de OpenClaw a NullClaw?**

Si. NullClaw tiene un comando de migracion integrado:

```bash
nullclaw migrate openclaw --dry-run
nullclaw migrate openclaw
```

**¿Como agrego un nuevo canal que no esta soportado?**

Implementa la interfaz vtable `Channel` en `src/channels/` y envia un PR. La arquitectura esta diseñada para extensiones.

</Accordion>

Si estas comparando aislamiento basado en contenedores, revisa nuestra [guia de despliegue de NanoClaw](/es/guia-despliegue-nanoclaw/) — usa contenedores Docker con el Agent SDK de Claude. Para una alternativa basada en Python con guias de configuracion de MiniMax y GLM-5, revisa la [guia de configuracion de nanobot](/es/guia-configuracion-nanobot/).

Si quieres explorar otras herramientas de codificacion con IA, nuestra [comparacion de herramientas de codificacion con IA](/ai-coading-tools/) cubre el panorama actual. Para conceptos basicos de MCP que funcionan en todos los asistentes, revisa la [introduccion a MCP para principiantes](/mcp-introduction-beginners/).

Este articulo tambien esta disponible en ingles: [NullClaw Deploy Guide](/nullclaw-deploy-guide/)