Cómo ejecutar nanobot 24/7 en un Mac mini dedicado (agente IA autoalojado)

1. ¿Por qué ejecutar nanobot en un Mac mini?

nanobot está construido en torno a un proceso gateway de larga duración: la documentación oficial indica mantener nanobot gateway en ejecución porque es el responsable de la entrega en segundo plano para las apps de chat, los topics de la WebUI, las automatizaciones programadas, los triggers locales y el heartbeat. Eso solo funciona en una máquina que nunca se duerme. Un Mac mini dedicado de MyRemoteMac te ofrece exactamente eso, un Mac Apple Silicon físico, solo tuyo, en línea 24/7 con un SLA del 99,9 %, root completo, acceso SSH y VNC y una VPN WireGuard, por un precio mensual fijo en lugar de la facturación de un VPS de tier GPU. Y como es macOS, nanobot puede usar su sandbox de ejecución Seatbelt integrado (sandbox-exec, incluido en macOS) y ejecutar un modelo local de Ollama en la misma máquina.

2. Requisitos previos

nanobot se distribuye como el paquete de PyPI nanobot-ai, con wheels de plataforma para macOS 13+ en Apple Silicon e Intel que incluyen la WebUI y la interfaz de terminal nativa. La ruta de instalación estándar no requiere Node.js, Homebrew ni Git. Esto es lo que necesitas:

• Un Mac mini dedicado de MyRemoteMac, M4 desde $85/mes (16 GB / 256 GB) o M6 desde $149/mes. Ambos son Apple Silicon y están cubiertos por el wheel arm64 para macOS.
• Acceso SSH a tu Mac mini (incluido con tu suscripción a MyRemoteMac) y una cuenta de usuario estándar, sin privilegios de root, para ejecutar nanobot, el SECURITY.md del proyecto indica que nunca se ejecute como root.
• Python 3.11 o superior y curl. El instalador de un solo comando se aborta si solo encuentra un python3 más antiguo; uv o pipx son opcionales pero recomendados cuando pip devuelve externally-managed-environment.
• Un proveedor de LLM: una clave API (Anthropic, OpenAI, OpenRouter, Gemini, DeepSeek, Groq, Mistral y unos 40 más vienen integrados) o un servidor local compatible con OpenAI como Ollama ejecutándose en el mismo Mac mini.
• Una cuenta de mensajería en Telegram, Discord, Slack o WhatsApp para comunicarte con tu agente (Telegram es la más rápida: un token de bot de @BotFather y ningún puerto entrante).

3. Paso 1: Conectar por SSH e instalar nanobot

Conéctate por SSH a tu Mac mini con las credenciales de tu panel de MyRemoteMac. Ejecuta todos los comandos de esta guía como un usuario normal de macOS, nunca como root: el LaunchAgent que instalarás más adelante se ejecuta dentro de la sesión de ese usuario.

Conectar por SSH y comprobar Python

# Connect to your Mac mini as a standard user (never root: SECURITY.md)
ssh admin@your-server-ip

# Confirm you are on Apple Silicon
uname -m
# arm64

# nanobot needs Python 3.11 or newer: install a current Python first if this is older
python3 --version
# Python 3.12.x

# curl is used to fetch the one-command installer
which curl

Instalar nanobot

La ruta por defecto del proyecto es un instalador de un solo comando que instala o actualiza nanobot-ai desde PyPI usando un entorno virtual activo, uv, pipx o un venv gestionado en ~/.nanobot/venv, e imprime el comando exacto que ha usado. Como SSH_CONNECTION está definida, omite la WebUI del navegador y ejecuta en su lugar el asistente de terminal nanobot onboard --wizard. Previsualízalo primero con --dry-run. Si prefieres gestionar la instalación tú mismo, uv y pipx son las alternativas documentadas:

# Option A, official one-command installer: preview, then run
curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh | sh -s -- --dry-run
curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh | sh
# Over SSH it runs the terminal wizard `nanobot onboard --wizard` instead of opening the WebUI.
# The script reads NANOBOT_SKIP_WIZARD / PYTHON from sh's own environment, so set them on sh, not on curl:
# curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh | NANOBOT_SKIP_WIZARD=1 sh
# curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh | PYTHON=/path/to/python3.12 sh

# Option B: uv (isolated tool install, no externally-managed-environment errors)
uv tool install nanobot-ai

# Option C: pipx, or pip inside a virtual environment
pipx install nanobot-ai
# python3 -m pip install nanobot-ai
# pip says "externally-managed-environment"? Use Option A or B: never --break-system-packages

Verificar la instalación

Si nanobot no está en tu PATH en un shell nuevo, usa el runner que imprimió el instalador (uv tool run, pipx run o el venv gestionado) o añade ~/.local/bin a tu PATH:

nanobot --version
# 0.3.5

# `nanobot` not found? Use the runner the installer printed:
uv tool run --from nanobot-ai nanobot --version
pipx run --spec nanobot-ai nanobot --version
~/.nanobot/venv/bin/python -m nanobot --version

4. Paso 2: Configurar un proveedor de modelos (API u Ollama local)

nanobot lee todo desde ~/.nanobot/config.json (proveedores, presets de modelos, canales, herramientas) y guarda la memoria, las skills y los archivos generados en ~/.nanobot/workspace/. El asistente de terminal crea ambos. Los fragmentos de configuración de la documentación oficial usan claves en camelCase y están pensados para fusionarse en el archivo, no para pegarse enteros. El archivo se lee una sola vez al arrancar, así que reinicia el gateway después de cada edición.

Ejecutar el asistente de terminal

# Documented path for SSH / headless installs (the installer already ran it unless skipped)
nanobot onboard --wizard
# Creates ~/.nanobot/config.json and ~/.nanobot/workspace/

# Later, after an upgrade: merge new default fields without overwriting your values
nanobot onboard --refresh

Añadir un proveedor y un preset de modelo

Un preset vincula un proveedor a un modelo. El ejemplo de la documentación es Anthropic directo con claude-opus-4-5; el fallo más común en el primer arranque es mezclar una clave API de un proveedor con un ID de modelo de otro, así que fija siempre el proveedor en el preset. Los ejemplos oficiales referencian la clave como ${ANTHROPIC_API_KEY}, resuelta desde el entorno del proceso que arranca nanobot y nunca escrita de vuelta. Eso funciona para sesiones en primer plano iniciadas desde tu shell (la herencia del entorno por el proceso desacoplado --background no está documentada), pero el LaunchAgent generado en el Paso 4 no lleva variables de entorno, así que para un despliegue con launchd guarda la clave en config.json y restringe el archivo como describe SECURITY.md:

# Merge into ~/.nanobot/config.json (key from console.anthropic.com)
{
  "providers": {
    "anthropic": { "apiKey": "sk-ant-YOUR_API_KEY_HERE" }
  },
  "modelPresets": {
    "primary": {
      "provider": "anthropic",
      "model": "claude-opus-4-5",
      "maxTokens": 8192,
      "contextWindowTokens": 200000
    }
  },
  "agents": { "defaults": { "modelPreset": "primary" } }
}

# Docs alternative for shell-started sessions: "apiKey": "${ANTHROPIC_API_KEY}"
# (resolved from the environment at startup; an unset variable fails fast with ConfigLoadError)

# Lock the config down (SECURITY.md)
chmod 700 ~/.nanobot && chmod 600 ~/.nanobot/config.json

Opcional: usar un modelo local con Ollama

nanobot tiene un proveedor ollama dedicado. Inicia Ollama en el Mac mini por separado (consulta nuestra guía de LLM en Mac mini) y luego apunta el proveedor a http://localhost:11434/v1, el nombre del modelo es la etiqueta de Ollama tal cual, sin prefijo, y la mayoría de las configuraciones de Ollama no necesitan clave API. Las cadenas de fallback referencian nombres de presets, así que puedes mantener un modelo frontier alojado como principal y un preset local como fallback (o a la inversa):

# Ollama must already be running on the Mac mini (started separately, outside nanobot)
# Merge into ~/.nanobot/config.json: model = raw Ollama tag, no prefix, no API key needed
{
  "providers": {
    "ollama": { "apiBase": "http://localhost:11434/v1" }
  },
  "modelPresets": {
    "primary": {
      "provider": "ollama",
      "model": "llama3.2",
      "maxTokens": 4096,
      "contextWindowTokens": 32768
    }
  },
  "agents": { "defaults": { "modelPreset": "primary" } }
}

# Fallback chains use preset names, not model IDs: context is sized for the smallest window in the chain
# "agents": { "defaults": { "modelPreset": "primary", "fallbackModels": ["localSmall"] } }

Comprobar la configuración y enviar un primer mensaje

La documentación es explícita: no añadas apps de chat, servidores MCP, fallbacks ni un servicio hasta que esto funcione.

# Check the setup without calling a model
nanobot status

# First one-shot message (since v0.3.5 a bare `nanobot` opens the terminal UI instead)
nanobot -m "Hello!"

5. Paso 3: Conectar canales de mensajería

La documentación de apps de chat de nanobot cubre Telegram, Discord, Slack, WhatsApp, WeChat, WeCom, Feishu/Lark, DingTalk, QQ, Matrix, correo electrónico, Mattermost, Linear, Microsoft Teams, Signal y Mochat, además de la WebUI integrada, la interfaz de terminal y una API compatible con OpenAI (nanobot serve). iMessage no está soportado. Las dependencias de los canales son funciones opcionales: actívalas con nanobot plugins enable <channel> antes de habilitar el canal en la configuración. Telegram es el más rápido de poner en marcha, long polling por defecto, así que ningún puerto entrante en el Mac mini. La guía de Telegram recomienda el modo de solo emparejamiento para la primera configuración: omite allowFrom y aprueba tu primer mensaje directo desde la CLI local de confianza:

# 1. In Telegram, open @BotFather, send /newbot and copy the token (format: 1234567890:AAF...)

# 2. Enable the optional Telegram feature in the same Python environment as nanobot
nanobot plugins enable telegram

# 3. Merge into ~/.nanobot/config.json: omit allowFrom to use pairing-only mode
{ "channels": { "telegram": { "enabled": true, "token": "1234567890:AAF..." } } }

# 4. The channel must be listed, then run the gateway in the foreground for a first test
nanobot channels status
nanobot gateway

# 5. DM your bot once: it answers with a pairing code. Approve it from a second SSH session:
nanobot agent -m "/pairing approve ABCD-EFGH"

# 6. Stop the foreground gateway with Ctrl+C before installing the service in Step 4

Conectar Discord, Slack o WhatsApp

Discord necesita un token de bot con el MESSAGE CONTENT INTENT activado en el Developer Portal; mantén el groupPolicy por defecto, mention, para que el bot solo responda cuando se le @menciona. Slack usa Socket Mode (un token de bot más un token a nivel de app con connections:write) y no necesita URL pública, pero los mensajes directos están abiertos por defecto, pon dm.policy en allowlist para obtener códigos de emparejamiento. WhatsApp se vincula mediante código QR y es Python puro desde la v0.3.0 (sin puente Node.js); su base de datos de sesión equivale a un acceso completo a la cuenta, así que mantén ~/.nanobot/whatsapp-auth con permisos 0700 y usa un número aparte:

# Discord: bot token with MESSAGE CONTENT INTENT enabled in the Developer Portal
{ "channels": { "discord": { "enabled": true, "token": "YOUR_DISCORD_BOT_TOKEN",
    "groupPolicy": "mention", "allowChannels": [] } } }

# Slack, Socket Mode (xoxb bot token + xapp app-level token with connections:write), no public URL
nanobot plugins enable slack
{ "channels": { "slack": { "enabled": true, "botToken": "xoxb-...", "appToken": "xapp-...",
    "dm": { "policy": "allowlist" } } } }

# WhatsApp: the CLI prints a QR code; scan it from WhatsApp > Linked Devices
# (if the QR is not readable in your terminal, run the same command over VNC; our advice: use a separate number)
nanobot plugins enable whatsapp
nanobot channels login whatsapp
{ "channels": { "whatsapp": { "enabled": true, "allowFrom": ["33612345678"] } } }
chmod 700 ~/.nanobot/whatsapp-auth   # session DB = full account access

# Every channel: verify it is listed, then restart the gateway
nanobot channels status

Control de acceso: allowFrom y emparejamiento

Todos los canales con mensajes directos siguen la misma regla. Con allowFrom omitido, el primer mensaje directo devuelve un código de emparejamiento que apruebas desde un chat ya aprobado o desde la CLI. Una lista no vacía es una lista de permitidos estricta: el resto se ignora. El comodín omite el emparejamiento y permite hablar con el bot a cualquiera que pueda alcanzar el canal, la documentación solo lo permite de forma intencionada o temporal en un sandbox privado, nunca en producción:

# channels.<name>.allowFrom semantics
#   omitted          → pairing-only mode: the first DM returns a code such as ABCD-EFGH
#   ["123456789"]    → static allowlist (your numeric Telegram/Discord ID), everyone else ignored
#   ["*"]            → anyone who can reach the channel: never in production

# Pairing management from the trusted local CLI
nanobot agent -m "/pairing approve ABCD-EFGH"
nanobot agent -m "/pairing deny ABCD-EFGH"
nanobot agent -m "/pairing revoke 123456789"

# Slack / Mattermost need "dm": { "policy": "allowlist" } to issue pairing codes;
# "dm": { "enabled": false } disables DMs where you do not need them

6. Paso 4: Reforzar la seguridad, ejecutar 24/7 con launchd, actualizar

Detén el gateway en primer plano (Ctrl+C) antes de continuar. nanobot documenta tres formas de mantener el gateway vivo en macOS: un LaunchAgent que escribe él mismo, un proceso en segundo plano desacoplado gestionado desde la CLI o un simple proceso en primer plano para pruebas. Para un Mac mini headless 24/7 usa el LaunchAgent, es la única opción que launchd supervisa y reinicia ante fallos. Refuerza primero la configuración.

Reforzar la seguridad antes de hacerlo persistente

La recomendación oficial de producción es usar tanto la protección del workspace a nivel de aplicación como el sandbox de ejecución del sistema operativo, Seatbelt en macOS. Seatbelt confina los comandos de shell del agente al workspace (lectura y escritura), a los medios (solo lectura) y a las rutas del sistema necesarias, oculta el directorio de configuración ~/.nanobot y apunta HOME y TMPDIR al workspace. No restringe el acceso a la red, y restrictToWorkspace por sí solo no es un sandbox del sistema operativo. Si el agente no necesita shell en absoluto, elimina la herramienta por completo. Mantén también tools.maxSessionMessagesPerMinute en su valor por defecto de 6 y establece un límite de gasto en tu proveedor de LLM:

# Official production recommendation on macOS: merge into ~/.nanobot/config.json
{
  "tools": {
    "restrictToWorkspace": true,
    "exec": { "sandbox": "seatbelt" }
  }
}

# Agent does not need a shell? Remove the tool entirely instead:
# { "tools": { "exec": { "enable": false } } }

# Seatbelt sets HOME and TMPDIR to the workspace and masks ~/.nanobot. Scripts that need
# extra paths get them via tools.exec.sandboxRoBinds / sandboxRwBinds (use sparingly).
# Neither Seatbelt nor bwrap restricts network access.

# Keep WebUI / API on localhost (defaults: WebUI 127.0.0.1:8765, health 127.0.0.1:18790, serve 127.0.0.1:8900)
# and leave tools.webuiAllowRemotePackageInstall = false and tools.ssrfWhitelist = []

Instalar el LaunchAgent

nanobot gateway install-service escribe ~/Library/LaunchAgents/ai.nanobot.gateway.plist, que ejecuta python -m nanobot gateway --foreground con tu Python actual, arranca al cargarse (RunAtLoad), se reinicia ante un fallo (KeepAlive con SuccessfulExit en false) y escribe los logs en ~/.nanobot/logs/. Falla con address already in use si todavía hay un gateway manual en ejecución, así que deténlo primero y previsualiza con --dry-run:

# Stop any manually started gateway first (otherwise: "address already in use")
nanobot gateway stop

# Preview the plist, then install it
nanobot gateway install-service --manager launchd --dry-run
nanobot gateway install-service --manager launchd
# Writes ~/Library/LaunchAgents/ai.nanobot.gateway.plist
# Runs: python -m nanobot gateway --foreground  (RunAtLoad, KeepAlive on failure)
# Logs: ~/.nanobot/logs/

Gestionar el servicio

El LaunchAgent vive en el dominio gui de tu usuario, así que se ejecuta en cuanto existe la sesión de inicio de ese usuario, la documentación lo describe como permanecer en línea después de iniciar sesión. Tras un reinicio de un Mac mini headless solo vuelve si tu usuario inicia sesión automáticamente; haz una prueba de reinicio y comprueba con launchctl list. Reinícialo después de cada edición de config.json:

# Is it loaded?
launchctl list | grep ai.nanobot.gateway

# Restart after every config.json edit (config is read at startup only)
launchctl kickstart -k gui/$(id -u)/ai.nanobot.gateway

# Remove the service
nanobot gateway uninstall-service --manager launchd

# Second, isolated instance on the same Mac (own config, workspace, port and LaunchAgent).
# docs/multiple-instances.md: "Each instance must use a different port if they run at the same time"
# nanobot onboard --config ~/.nanobot-telegram/config.json --workspace ~/.nanobot-telegram/workspace
# Merge into ~/.nanobot-telegram/config.json (default gateway port is 18790; change the WebSocket
# channel port too if that instance also enables the WebUI, default 8765):
# { "gateway": { "host": "127.0.0.1", "port": 18792 },
#   "channels": { "websocket": { "port": 8766 } } }
# nanobot gateway install-service --manager launchd --name nanobot-telegram \
#   --config ~/.nanobot-telegram/config.json --workspace ~/.nanobot-telegram/workspace
# (for a one-off foreground run instead: nanobot gateway --config ~/.nanobot-telegram/config.json --port 18792)

Alternativa más ligera: nanobot gateway --background

El README lo llama el único comando que promueve el gateway compartido al modo persistente en segundo plano. Es cómodo para pruebas pero no está supervisado por el sistema operativo, así que no vuelve por sí solo tras un reinicio, no lo mezcles con el LaunchAgent:

nanobot gateway --background
nanobot gateway status
nanobot gateway logs
nanobot gateway restart
nanobot gateway stop

Actualizar nanobot

No existe un comando nanobot update: actualiza con el mismo método que usaste para instalar. El proyecto pide comprobar las actualizaciones cada semana y publicó cinco avisos de seguridad en 2026, así que actualiza sin demora. Lee primero las notas de la versión, la v0.3.5 movió los archivos de sesión a sessions/<workspace-id>/ e indica hacer una copia de seguridad de la configuración, los workspaces y el almacenamiento de sesiones y detener antes los procesos antiguos. Así que detén el gateway (desinstala el LaunchAgent o nanobot gateway stop en modo background), haz la copia de seguridad, actualiza y vuelve a arrancarlo, nunca dejes que dos versiones escriban en el mismo workspace a la vez:

# 1. Stop the old gateway first (v0.3.5 release notes: never let two versions write the same workspace)
nanobot gateway uninstall-service --manager launchd   # LaunchAgent (nanobot documents no plain launchd stop)
# nanobot gateway stop                                  # --background mode

# 2. Back up config, workspace and sessions
cp -R ~/.nanobot ~/nanobot-backup-$(date +%F)

# 3. Upgrade with the same method you installed with
curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh | sh
# or: uv tool upgrade nanobot-ai
# or: pipx upgrade nanobot-ai
# or: python3 -m pip install -U nanobot-ai

nanobot --version
nanobot onboard --refresh      # merge new default config fields, keep your values

# 4. Start again so the new code and config are loaded
nanobot gateway install-service --manager launchd     # LaunchAgent: reinstall (RunAtLoad starts it)
# nanobot gateway --background                          # --background mode

7. Resolución de problemas comunes

# Python too old? Point the installer at a 3.11+ interpreter
python3 --version
PYTHON=/path/to/python3.12 sh -c "$(curl -fsSL https://raw.githubusercontent.com/HKUDS/nanobot/main/scripts/install.sh)"

# "externally-managed-environment" → isolated install, never --break-system-packages
uv tool install nanobot-ai
# or: pipx install nanobot-ai

# "curl: command not found" → skip the script
uv tool install nanobot-ai

# `nanobot` not on PATH in a new shell
uv tool run --from nanobot-ai nanobot --version
pipx run --spec nanobot-ai nanobot --version
~/.nanobot/venv/bin/python -m nanobot --version
export PATH="$HOME/.local/bin:$PATH"

# Validate without spending tokens
nanobot status

# Provider and model must match in the preset: provider "anthropic" ↔ "claude-opus-4-5",
# provider "openai" ↔ "gpt-5", provider "openrouter" ↔ "anthropic/claude-opus-4.5", provider "ollama" ↔ "llama3.2"

# ConfigLoadError at startup = a ${VAR} placeholder is unset in the starting process' environment
# (the generated LaunchAgent passes no environment → store the key in config.json + chmod 600)

# Watch the gateway with verbose logging (also verifies MCP servers)
nanobot gateway --verbose

# Is the channel enabled and listed?
nanobot plugins enable telegram
nanobot channels status

# Pending pairing? Approve it from the CLI
nanobot agent -m "/pairing approve ABCD-EFGH"

# Edited config.json? Restart the gateway
launchctl kickstart -k gui/$(id -u)/ai.nanobot.gateway
# or: nanobot gateway restart

# Token revoked? Generate a new one via @BotFather (/mybots > API Token) and update config.json
# WhatsApp "login expired"? nanobot channels login whatsapp

# "address already in use" → a manual gateway still holds the port
nanobot gateway stop
nanobot gateway install-service --manager launchd

# Loaded? Logs?
launchctl list | grep ai.nanobot.gateway
ls ~/.nanobot/logs/

# Gone after a reboot: a gui-domain LaunchAgent starts once your user has logged in.
# If your setup allows automatic login for the nanobot user, enable it and reboot-test;
# WARNING: auto-login trades console-login security for reboot survival, confirm with your ops policy first.

# Ports: WebUI 8765 (localhost), health endpoint 18790, `nanobot serve` API 8900
# Generic SSH tip (not a nanobot feature): reach the localhost WebUI from your laptop
# ssh -N -L 8765:127.0.0.1:8765 admin@your-server-ip   → http://127.0.0.1:8765

8. Análisis de costes vs. VPS cloud

nanobot en sí es gratuito (MIT). Lo que pagas es el host y el uso del LLM. La comparativa de hosts de abajo reutiliza los rangos de VPS cloud de nuestras guías de OpenClaw y Hermes; el uso de la API del LLM lo factura aparte tu proveedor y es idéntico en cualquiera de los dos hosts, salvo que ejecutes un modelo local de Ollama en el Mac mini, en cuyo caso la inferencia cuesta $0. nanobot no publica cifras de consumo de RAM ni de CPU (solo se describe como ultraligero), así que el dimensionado de planes de abajo es cualitativo.

Supuestos: los precios de VPS son los mismos rangos usados en todas nuestras guías para instancias de tier IA con GPU y no son presupuestos de un proveedor concreto; los precios de MyRemoteMac son las tarifas mensuales actuales en USD (1 Gbps incluido, Mac mini M6 disponible desde el 22 de septiembre de 2026). La división M4/M6 es una recomendación, no un requisito medido: un Mac mini M4 es más que suficiente para un bot personal con proveedores alojados; elige el M6 cuando la misma máquina también sirva un modelo local de Ollama o varias instancias de nanobot.

9. nanobot vs. OpenClaw

Ambos son agentes IA personales de código abierto (MIT), autoalojados y always-on, controlados desde tus apps de chat; ambos ejecutan un gateway de larga duración y ambos registran su propio LaunchAgent de launchd (ai.nanobot.gateway vs ai.openclaw.gateway). El README de nanobot incluso llama a nanobot gateway el punto de entrada familiar si vienes de OpenClaw. Las diferencias están en el stack y en el enfoque. OpenClaw es TypeScript sobre Node.js (26.1+ o 24.16+ vía Homebrew) instalado con npm; nanobot es Python 3.11+ desde PyPI (nanobot-ai), instalado con un script de una línea, uv o pipx, sin Node.js en absoluto. La propuesta de OpenClaw es la amplitud y una comunidad mayor; la de nanobot es un núcleo pequeño y legible, emparejamiento por canal más un sandbox de ejecución Seatbelt de macOS integrado (nuevo en la v0.3.5), varias instancias aisladas en un mismo Mac (multiple-instances.md) y un SDK de Python más una API compatible con OpenAI. OpenClaw es compatible con iMessage; nanobot no.

Si quieres el asistente más completo y la comunidad y la lista de canales más amplias, lee nuestra guía de OpenClaw en Mac mini. Si quieres un agente ligero en Python que puedas leer de principio a fin, varias instancias en sandbox u Ollama en el mismo Mac mini, nanobot encaja mejor. Una tercera opción, Hermes Agent, se trata en nuestra guía de Hermes en Mac mini. El Mac mini, el servicio launchd y la opción de Ollama local son los mismos para los tres.

10. Preguntas frecuentes

11. Fuentes y lecturas adicionales

Todos los comandos, rutas y claves de configuración de esta guía proceden del repositorio oficial de nanobot (README y árbol docs/, consultados el 28 de septiembre de 2026, v0.3.5) y de su SECURITY.md. La documentación del repositorio puede ser más reciente que la última versión publicada del paquete, así que vuelve a comprobarla contra el repositorio si un comando se comporta de forma distinta.

• Repositorio GitHub de nanobot (HKUDS/nanobot): Instalación y Quick Start
• Quick start (config.json, workspace, actualización con el mismo método)
• Despliegue: LaunchAgent de macOS (install-service, launchctl kickstart)
• Referencia de configuración (secretos, marcadores ${VAR}, MCP, herramientas web)
• Configuración: Seguridad (restrictToWorkspace, sandbox Seatbelt, exec.enable)
• Proveedores (presets, cadenas de fallback, discrepancia proveedor/modelo)
• Proveedores: Ollama (apiBase /v1, etiqueta de modelo tal cual)
• Apps de chat (Telegram, Discord, Slack, WhatsApp, allowFrom, emparejamiento)
• Guía: agente IA en Telegram (modo de solo emparejamiento, configuración headless)
• Guía: agente IA local seguro (enlace a localhost, un workspace por límite de confianza)
• Referencia de la CLI (onboard --wizard / --refresh, gateway, plugins, channels)
• WebUI (127.0.0.1:8765, tokenIssueSecret, acceso LAN)
• Automatizaciones (herramienta cron, triggers locales, heartbeat)
• Varias instancias en una misma máquina
• Resolución de problemas (Python 3.11+, externally-managed-environment, puertos)
• SECURITY.md (nunca ejecutar como root, chmod 600/700, limitaciones conocidas)
• Avisos de seguridad (cinco publicados en 2026)
• Versión v0.3.5 (15 de septiembre de 2026: estructura de sesiones, Seatbelt, ciclo de vida del gateway)
• PyPI: nanobot-ai (requiere Python 3.11+, wheels para macOS 13+)

Guías relacionadas