nanobot vs OpenClaw vs Hermes Agent: Which Self-Hosted AI Assistant Fits a Small VPS

In the nanobot vs OpenClaw question, the short answer for a small server is this: nanobot v0.4.0 idled at 160 to 178 MB of RAM in our lab and installs in 20 seconds, OpenClaw's gateway idled at about 1 GB in our October tests, and Hermes Agent sits in between at about 220 MB idle but 2.5 GB on disk. So nanobot and Hermes fit a 2 GB VPS Micro with a hosted model API, OpenClaw wants a 4 GB VPS Mini, and any of the three with a local model on the same box belongs on a VDS. This self-hosted AI assistant comparison is built from what we measured: we installed nanobot in a fresh Debian 13 container limited to 2 GiB and 2 vCPUs on 29 October 2026, ran it against a 0.5B model in Ollama, and reused the numbers from our earlier OpenClaw and Hermes labs with the versions they were measured on. All three are "personal AI agents": a program on your server that takes a message from a chat app, sends it to a language model (local or at an API provider), lets the model call tools such as a shell or a web search, and answers. The differences are in how much ships around that loop.

Key facts, checked on 29 October 2026:

• nanobot (HKUDS) is Python, MIT, Python 3.11 or newer, installed with uv tool install nanobot-ai or pip; the repository was created on 1 February 2026 and had 49,628 stars; v0.4.0 was released on 28 October 2026 (nanobot on GitHub, releases).
• OpenClaw is TypeScript on Node.js (Node 24.16+ or 26, Node 26 recommended), MIT, 393,358 stars; 2026.10.9 was released on 29 October 2026, the ninth stable release of the month after 2026.10.1 to 2026.10.8 (OpenClaw releases, install docs).
• Hermes Agent (Nous Research) is Python (the installer pins Python 3.14), MIT, 258,425 stars; v0.22.5 was released on 22 October 2026 (Hermes releases).
• Our lab: nanobot v0.4.0 used 359 MB of disk, started its gateway in 3.0 to 4.2 seconds and idled at 160 to 178 MB; Ollama 0.40.13 with Qwen2.5 0.5B added 518 MB at a 4,096-token context and about 1 GB at 32,768 tokens.
• Our earlier labs: OpenClaw 2026.10.2 gateway 988 to 1,053 MB idle, 1,378 MB with six parallel chats (OpenClaw guide); Hermes v0.21.7 gateway 218 to 225 MB idle, 273 MB while answering (Hermes guide).

nanobot vs OpenClaw vs Hermes Agent: the comparison table

Everything here comes from the projects' README and documentation as read on 29 October 2026, plus our measurements where marked. Channel connectors need bot tokens, so we did not test them; they are listed as documented.

MCP, the Model Context Protocol, is a standard way to plug tools into an agent (see our MCP server guide). All three speak it; only OpenClaw also hosts MCP Apps, interactive panels beside the chat added in 2026.10.1 (release notes), and a "Sign in" button for remote MCP servers that use OAuth (MCP docs), which our post on OpenClaw MCP connectors covers. On memory, nanobot and Hermes keep plain Markdown you can edit; OpenClaw adds an embedding index that wants an API key (memory docs).

What we measured: nanobot on a 2 GB container

One Debian 13 Incus container on our Amsterdam test server, limited to 2 GiB and 2 vCPUs, the shape of our VPS Micro. We installed nanobot the way its README recommends, as an unprivileged user called nano:

# as the nano user
pipx install uv
export PATH=$HOME/.local/bin:$PATH
time uv tool install nanobot-ai
nanobot --version

Installed 2 executables: nanobot, nanobot-desktop-tui
real    0m20.153s
nanobot v0.4.0

Installing uv took another 15 seconds; the tool environment measured 359 MB with 226 packages, and the nanobot package itself is about 144,000 lines of Python, so "ultra-lightweight" describes the runtime, not the reading. Then Ollama, the program that runs small open models on a CPU, as root. Its installer stopped with "This version requires zstd for extraction", so install zstd first:

# as root
apt-get install -y zstd
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5:0.5b

>>> Installing ollama to /usr/local
WARNING: Unable to detect NVIDIA/AMD GPU.
real    1m53.912s
qwen2.5:0.5b    a8b0c5157701    397 MB

Ollama 0.40.13 put 2.3 GB in /usr/local/lib/ollama (mostly GPU code a VPS never uses) and idled at 38 to 40 MB; the model is another 397 MB.

The config, and the first error

nanobot reads ~/.nanobot/config.json; the provider cookbook gives the Ollama recipe. Ours, with the workspace guard on:

# as the nano user, ~/.nanobot/config.json
{
  "providers": { "ollama": { "apiBase": "http://localhost:11434/v1" } },
  "modelPresets": {
    "local": { "provider": "ollama", "model": "qwen2.5:0.5b",
               "maxTokens": 512, "contextWindowTokens": 32768, "temperature": 0.2 }
  },
  "agents": { "defaults": { "modelPreset": "local" } },
  "tools": { "restrictToWorkspace": true }
}

We first set contextWindowTokens to 8192, and every message failed before reaching the model:

ContextWindowExceededError: Model input exceeds the local context budget for cli:direct: 26780/6656 via heuristic

That line matters: nanobot's system prompt with its 23 tool schemas is large (its own estimate 26,780 tokens; Ollama's tokeniser counted 5,490 for the real request), so an 8k context is too small and a small model has to read that prompt on every cold turn. At 32,768 tokens, with Ollama's context raised to match, chats worked:

# as the nano user
time nanobot -m "Reply in one short sentence: what is a VPS?"

A Virtual Private Server (VPS) is a server that is physically located in a data
center and is provisioned with a physical server.
real    1m29.576s

Ollama's log explains the 90 seconds: "prompt eval time = 82838.79 ms / 5490 tokens (66.27 tokens per second)", then 29 answer tokens at 12.95 per second. The second message, with the prompt cached, took 4.9 seconds. Asked to use its list_dir tool, the 0.5B model invented six file names and repeated the VPS sentence: half a billion parameters can chat, but cannot be trusted with tools.

RAM and startup, measured

Context size is the lever that matters: the KV cache (the model's working memory for the conversation) grew the runner from 518 MB to about 1 GB between 4k and 32k tokens, so a 1.5B model with that context would not fit a 2 GB server next to anything else. (One lab artefact for the curious: our container saw the host's 8 CPUs while limited to 2, Ollama started 8 threads, and generation fell to 0.1 tokens per second until we pinned num_thread to 2; a KVM guest sees exactly its plan's vCPUs, so a real VPS does not have this problem.)

OpenClaw and Hermes Agent: the numbers from our earlier labs

We did not reinstall these two; the figures are what we measured and published, with the version each was taken on. Both projects have shipped several releases since, so read them as the right order of magnitude.

Both, with Paperclip, Claude Code and browser agents, are compared in our AI agent VPS requirements post.

Which self-hosted AI assistant for whom

nanobot: one chat channel, a small footprint, files you can read

Pick nanobot for an assistant on Telegram or in a browser tab, memory as Markdown files in a git repository, and the smallest footprint of the three: a 160 to 178 MB idle gateway installed with one uv command, no Node, browser or compiler. The price is polish: the WebUI sits on a WebSocket port you must tunnel to, every channel beyond it is a plugin you enable, and v0.4.0 only arrived on 28 October, so read the deployment doc and expect rough edges. It suits one person who wants to understand what runs on their VPS.

OpenClaw: the gateway with everything plugged in

Pick OpenClaw for many channels on one gateway, the longest provider list, MCP servers with OAuth sign-in and MCP Apps, and a project that ships fixes almost daily. You pay in memory (plan 4 GB), in update work (nine stable releases in October, each worth reading the notes for), and in a security surface that needs the care in our OpenClaw hardening guide: in our lab the default tool profile ran shell commands on the host without asking.

Hermes Agent: the agent that writes its own skills

Pick Hermes if the "self-improving" idea appeals: it writes skills after complex tasks, searches its whole session history, and has the most explicit approval model of the three (dangerous commands are denied if nobody answers, per the Hermes security docs). The gateway is light, but the install is 2.5 GB, brings its own Python, Node, ripgrep and FFmpeg, and prefers a Docker sandbox on a server. Our Hermes guide covers the Telegram setup and the swap file a 1 GB server needs.

If you only need a bot that answers commands with no language model behind it, see our Telegram and Discord bot hosting guide instead.

Sizing: measured RAM to the smallest plan with headroom

Headroom means the operating system, SSH, a reverse proxy and the agent's busy peak still leave about a quarter of the memory free. The plans are ours: VPS Nano 1 vCPU / 1 GB, VPS Micro 2 vCPU / 2 GB, VPS Mini 4 vCPU / 4 GB (shared vCPUs) and VDS Small 4 dedicated vCPU / 8 GB, all KVM with NVMe and their own IPv4 and IPv6 (VPS and VDS plans).

About CPU-only inference: a 0.5B model gave us 37 tokens per second on 2 vCPUs with a short context and 12 to 14 with the context nanobot needs; a 2B-class model on 4 vCPUs gave about 20 in our BitNet on a CPU VPS test. Fine for a private chat, too slow for an agent that makes five tool calls per answer, and none of our plans has a GPU. Most people will point the agent at a hosted API and keep the VPS for what must run all day: the gateway, the memory files and the channel connections. If you later want a local model, the upgrade from Micro to Mini to VDS Small is done from the client area with a short reboot.

The security checklist all three share

Each agent runs shell commands on your server when the model decides to, so do these before you connect a chat app:

1. Bind to localhost. nanobot and OpenClaw do this by default on a host install, and Hermes's gateway opens no inbound port unless you enable its API server; OpenClaw's container images default to an exposed bind and need a token (OpenClaw security docs). Check with ss -tlnp that nothing listens on 0.0.0.0.
2. Reach the web UI through an SSH tunnel or a reverse proxy with authentication, never a bare port. nanobot's docs say remote WebUI users "share saved topics and administrative controls" (nanobot WebUI docs). The tunnel is one command: ssh -L 8765:127.0.0.1:8765 nano@YOUR_SERVER_IP.
3. Firewall. ufw default deny incoming, allow SSH, nothing else until a reverse proxy needs 443.
4. Run the agent as a user without sudo and turn on its sandbox: tools.exec.sandbox: "bwrap" in nanobot (nanobot configuration), the Docker sandbox in OpenClaw, terminal.backend: docker in Hermes. Neither nanobot's bubblewrap nor Hermes's write-denylist blocks network access.
5. Lock the chat channel to yourself. All three pair unknown direct-message senders by code; set allowFrom or the allowlist to your own user ID, never to "everyone".
6. Updates. Watch the releases page. OpenClaw and Hermes ship weekly or faster; nanobot's v0.4.0 notes say to back up the whole instance while stopped before upgrading, because older versions cannot read the new SQLite history.
7. Backups. The memory files and SQLite databases are the agent; everything else is reinstallable. Our Prishtina servers include a free weekly backup (last two kept) restored with one click from the client area, plus an optional daily add-on. Amsterdam and Dublin servers do not include backups, so copy ~/.nanobot, ~/.openclaw or ~/.hermes elsewhere nightly; our OpenClaw backup post shows a restic setup that used 28 MB of RAM.

Frequently asked questions

Is nanobot lighter than OpenClaw?

Yes, by a wide margin in our labs: nanobot v0.4.0's gateway idled at 160 to 178 MB of RAM and used 359 MB of disk; OpenClaw 2026.10.2's gateway idled at 988 to 1,053 MB and used 820 MB of disk including its bundled Node. Both figures are with the model at an API provider.

Can nanobot run on a 1 GB VPS?

With a hosted model API, yes: the gateway needs under 200 MB and Debian 13 about 100 MB. With a local model in Ollama, no; our 0.5B model alone took 518 MB at a 4k context and about 1 GB at the 32k context nanobot's prompt needs, so 2 GB is the floor for that setup.

Hermes Agent vs OpenClaw: which is better for a small server?

Hermes on memory: its gateway idled at about 220 MB against OpenClaw's roughly 1 GB, so it fits a 2 GB VPS Micro while OpenClaw needs a 4 GB VPS Mini. OpenClaw wins when you want many chat channels on one gateway, MCP Apps and OAuth sign-in for remote MCP servers. Hermes's install is bigger on disk (2.5 GB).

Which local model should I use with nanobot on a CPU?

For chatting, a 0.5B to 1.5B model in Ollama works on 2 to 4 GB. For tool use, our 0.5B test invented file names when asked to list a directory, so use at least a 1.5B to 3B model on a 4 or 8 GB plan, or a hosted API. Keep the context at 32k or more; nanobot's system prompt with 23 tool schemas was 5,490 tokens on its own.

Are the chat connectors safe to expose?

The connectors connect outward to Telegram, Discord or Slack, so no inbound port is needed. The web UIs are different: keep them on 127.0.0.1 behind an SSH tunnel or an authenticated reverse proxy, and keep the default that pairs unknown senders by code.

Pick the agent, then the plan

For nanobot or Hermes with a hosted model, start on a VPS Micro (2 vCPU, 2 GB, 40 GB NVMe); for OpenClaw, a VPS Mini (4 vCPU, 4 GB, 80 GB); for any agent next to a local model you actually use, a VDS Small (4 dedicated vCPU, 8 GB, 240 GB). All are on the VPS and VDS plans page, deployed in under 60 seconds after payment in Amsterdam, Dublin or Prishtina, and a Prishtina server includes the weekly backup that keeps the agent's memory files safe (VPS Kosovo). Not sure which of the three fits? Write to us on Telegram with what the assistant should do and which chat app you live in.

← All articles