"Security at the expense of usability comes at the expense of security." — AviD's Rule of Usability
「以犧牲可用性為代價的安全，最終會犧牲安全本身。」—— AviD 可用性法則
Why Not Just Use OpenClaw?
OpenClaw proved the concept: a self-hosted AI assistant that connects to your messaging apps and takes autonomous actions. With 320k+ GitHub stars and 5,400+ community skills on ClawHub, it's the category king.
But OpenClaw has structural problems:
- 434,000 lines of TypeScript, 53 config files, 70+ dependencies — nearly impossible to audit
- 1+ GB RAM usage with 500ms+ cold starts
- 9 CVEs and counting, including CVE-2026-25253 (remote code execution)
- 36% of audited ClawHub skills contain prompt injection vulnerabilities
- Agents run bare-metal on the host with application-level permission checks
NanoClaw and ZeroClaw both agree: OpenClaw's security model is fundamentally flawed. But they disagree completely on how to fix it.
| Philosophy | NanoClaw | ZeroClaw |
|---|---|---|
| Core thesis | Trust no agent — isolate everything in containers | Trust no bloat — rewrite everything in Rust |
| Language | TypeScript (~3,900 lines) | Rust (3.4 MB binary) |
| Security approach | OS-level isolation (containers) | Language-level safety (Rust ownership) + encrypted secrets |
| Stars | ~23.8k | ~27.6k |
| Created | January 31, 2026 | February 2024 |
| License | MIT | MIT + Apache 2.0 |
為什麼不直接用 OpenClaw？
OpenClaw 證明了這個概念：一個自架的 AI 助手，連接你的通訊軟體並自主執行動作。擁有超過 320k GitHub 星和 ClawHub 上 5,400+ 個社群 skill，它是這個類別的霸主。
但 OpenClaw 有結構性問題：
- 434,000 行 TypeScript、53 個設定檔、70+ 個相依套件——幾乎不可能審計
- 1+ GB 記憶體使用，冷啟動 500ms 以上
- 9 個 CVE 且持續增加，包括 CVE-2026-25253（遠端程式碼執行）
- 36% 被審計的 ClawHub skill 包含 prompt injection 漏洞
- Agent 在主機上裸跑，使用應用層級的權限檢查
NanoClaw 和 ZeroClaw 都同意：OpenClaw 的安全模型根本上有缺陷。但它們對如何修復完全持不同意見。
| 哲學 | NanoClaw | ZeroClaw |
|---|---|---|
| 核心論點 | 不信任任何 agent——把一切隔離在容器中 | 不信任任何膨脹——用 Rust 重寫一切 |
| 語言 | TypeScript（約 3,900 行） | Rust（3.4 MB 二進位檔） |
| 安全方式 | 作業系統層級隔離（容器） | 語言層級安全（Rust 所有權）+ 加密 secret |
| 星數 | 約 23.8k | 約 27.6k |
| 建立日期 | 2026 年 1 月 31 日 | 2024 年 2 月 |
| 授權 | MIT | MIT + Apache 2.0 |
NanoClaw: The Container-First Minimalist
Architecture
NanoClaw is a single Node.js process that orchestrates ephemeral containers. Every agent session — every chat group — gets its own isolated container with its own filesystem, Claude session, and memory.
Messages (WhatsApp/Telegram/Slack/Discord)
│
▼
SQLite (message store)
│
▼
Polling Loop (orchestrator, ~3,900 lines TypeScript)
│
▼
┌─────────────────────────────────────────────┐
│ Container per group │
│ ┌─────────────┐ ┌──────────┐ ┌────────┐ │
│ │ Claude Agent │ │ CLAUDE.md│ │ Files │ │
│ │ SDK │ │ (memory) │ │(mounted│ │
│ │ │ │ │ │ r/w) │ │
│ └─────────────┘ └──────────┘ └────────┘ │
└─────────────────────────────────────────────┘The entire codebase is ~15 files. You can read the whole thing in under 8 minutes. At 34.9k tokens, an AI can reason about the full project in a single context window — which is the point.
Key source files:
| File | Purpose |
|---|---|
src/index.ts | Orchestrator: state machine, message loop, agent invocation |
src/container-runner.ts | Container lifecycle management |
src/group-queue.ts | Per-group FIFO queue, 3 concurrent containers by default |
src/channels/registry.ts | Auto-detect channels by which credentials are present |
src/db.ts | SQLite operations |
src/task-scheduler.ts | Scheduled and recurring tasks |
Security Model
NanoClaw's security thesis: agents are untrusted and potentially malicious. Don't try to check permissions in code — use OS-level isolation.
Three container runtime tiers:
| Tier | Runtime | Isolation Level | Platform |
|---|---|---|---|
| 1 | Docker Sandboxes | Hypervisor-level (microVM, own kernel) | macOS Apple Silicon, Windows |
| 2 | Docker | Standard container isolation | macOS, Linux |
| 3 | Apple Container | Native macOS container | macOS |
What's isolated per agent:
- Own filesystem — agents can't see each other's data
- Own Claude session — no context leakage between groups
- Unprivileged user — no root access
- Host code mounted read-only
- Bash access is safe — commands execute inside the container, not on the host
Mount allowlist (~/.config/nanoclaw/mount-allowlist.json):
Stored outside the project directory so a compromised agent can't modify its own permissions. Blocks .ssh, .gnupg, .aws, .env, private_key, credentials by default.
Honest limitation: Container isolation "contains damage" — it doesn't eliminate risk. The "lethal trifecta" (data access + untrusted content + external communication) means prompt injection can still exploit pathways within the container's scope.
LLM Support
Claude-optimized via Anthropic Agent SDK. Other LLMs (Ollama, Together AI, Fireworks) require middleware. This is the biggest trade-off — NanoClaw is effectively Claude-only for most users.
Messaging Platforms
| Platform | Status | Notes |
|---|---|---|
| Built-in | QR code or pairing code auth | |
| Telegram | Via skill | Standalone or paired mode |
| Telegram Swarm | Via skill | Multi-agent with individual bot identities |
| Discord | Built-in | Text channels with attachments |
| Slack | Built-in | Socket Mode (no public URL needed) |
| Gmail | Via skill | Read, send, search, draft |
| Signal | Planned | RFS (Request for Skill) status |
Capabilities (18 Official Skills)
Messaging: WhatsApp, Telegram, Telegram Swarm, Discord, Slack
Tools: Agent Browser (pages, forms, screenshots), Gmail, PDF Reader, Image Vision, Local Whisper (on-device voice transcription), Ollama (local AI), Smart Home (Home Assistant)
Utility: Compact (context compaction), Debug, Customize, Update NanoClaw
Setup
gh repo fork qwibitai/nanoclaw --clone
cd nanoclaw
claude
/setupNo config files. The philosophy is "AI-native" — Claude Code guides your setup conversationally. To customize, you tell Claude what you want and it modifies the codebase directly.
Community
- 23.8k stars, 6.4k forks, 53+ contributors
- Docker partnership (March 13, 2026) — first claw platform integrated with Docker Sandboxes
- Andrej Karpathy public endorsement
- Media: TechCrunch, VentureBeat, The Register, Fortune, CNBC
- Active Discord server
NanoClaw：容器優先的極簡主義者
架構
NanoClaw 是一個單一 Node.js 程序，編排短暫的容器。每個 agent session——每個聊天群組——都有自己隔離的容器，包含自己的檔案系統、Claude session 和記憶。
訊息（WhatsApp/Telegram/Slack/Discord）
│
▼
SQLite（訊息儲存）
│
▼
輪詢迴圈（編排器，約 3,900 行 TypeScript）
│
▼
┌─────────────────────────────────────────────┐
│ 每個群組一個容器 │
│ ┌─────────────┐ ┌──────────┐ ┌────────┐ │
│ │ Claude Agent │ │ CLAUDE.md│ │ 檔案 │ │
│ │ SDK │ │ （記憶） │ │（掛載 │ │
│ │ │ │ │ │ r/w） │ │
│ └─────────────┘ └──────────┘ └────────┘ │
└─────────────────────────────────────────────┘整個 codebase 約 15 個檔案。你可以在 8 分鐘內讀完。34.9k token，AI 可以在單一 context window 中推理整個專案——這正是重點。
關鍵原始碼檔案：
| 檔案 | 用途 |
|---|---|
src/index.ts | 編排器：狀態機、訊息迴圈、agent 呼叫 |
src/container-runner.ts | 容器生命週期管理 |
src/group-queue.ts | 每群組 FIFO 佇列，預設 3 個並行容器 |
src/channels/registry.ts | 根據存在的憑證自動偵測頻道 |
src/db.ts | SQLite 操作 |
src/task-scheduler.ts | 排程與循環任務 |
安全模型
NanoClaw 的安全論點：agent 是不受信任且可能有惡意的。不要試圖在程式碼中檢查權限——使用作業系統層級的隔離。
三種容器 runtime 層級：
| 層級 | Runtime | 隔離等級 | 平台 |
|---|---|---|---|
| 1 | Docker Sandboxes | Hypervisor 層級（microVM，獨立 kernel） | macOS Apple Silicon、Windows |
| 2 | Docker | 標準容器隔離 | macOS、Linux |
| 3 | Apple Container | 原生 macOS 容器 | macOS |
每個 agent 被隔離的內容：
- 自己的檔案系統——agent 看不到彼此的資料
- 自己的 Claude session——群組間沒有 context 洩漏
- 非特權使用者——沒有 root 存取
- 主機程式碼以唯讀方式掛載
- Bash 存取是安全的——指令在容器內執行，不在主機上
掛載白名單（~/.config/nanoclaw/mount-allowlist.json）：
儲存在專案目錄外，被入侵的 agent 無法修改自己的權限。預設封鎖 .ssh、.gnupg、.aws、.env、private_key、credentials。
誠實的限制： 容器隔離「控制損害」——不能消除風險。「致命三重奏」（資料存取 + 不受信任的內容 + 外部通訊）意味著 prompt injection 仍能利用容器範圍內的路徑。
LLM 支援
透過 Anthropic Agent SDK 針對 Claude 優化。其他 LLM（Ollama、Together AI、Fireworks）需要中介軟體。這是最大的取捨——對大多數使用者來說，NanoClaw 實質上是 Claude 專用。
訊息平台
| 平台 | 狀態 | 備註 |
|---|---|---|
| 內建 | QR code 或配對碼認證 | |
| Telegram | 透過 skill | 獨立或配對模式 |
| Telegram Swarm | 透過 skill | 多 agent，各有獨立 bot 身份 |
| Discord | 內建 | 文字頻道含附件 |
| Slack | 內建 | Socket Mode（不需公開 URL） |
| Gmail | 透過 skill | 讀取、傳送、搜尋、草稿 |
| Signal | 計畫中 | RFS（Request for Skill）狀態 |
能力（18 個官方 Skill）
訊息： WhatsApp、Telegram、Telegram Swarm、Discord、Slack
工具： Agent Browser（頁面、表單、截圖）、Gmail、PDF Reader、Image Vision、Local Whisper（裝置上語音轉錄）、Ollama（本地 AI）、Smart Home（Home Assistant）
實用工具： Compact（context 壓縮）、Debug、Customize、Update NanoClaw
安裝
gh repo fork qwibitai/nanoclaw --clone
cd nanoclaw
claude
/setup沒有設定檔。哲學是「AI 原生」——Claude Code 以對話方式引導你完成設定。要自訂，你告訴 Claude 你想要什麼，它直接修改 codebase。
社群
- 23.8k 星、6.4k fork、53+ 貢獻者
- Docker 合作夥伴關係（2026 年 3 月 13 日）——第一個與 Docker Sandboxes 整合的 claw 平台
- Andrej Karpathy 公開推薦
- 媒體：TechCrunch、VentureBeat、The Register、Fortune、CNBC
- 活躍的 Discord 伺服器
ZeroClaw: The Rust Performance Purist
Architecture
ZeroClaw is a single compiled Rust binary. No Node.js, no Python, no runtime interpreter. Three discrete services:
┌──────────────────────────────────────────────┐
│ zeroclaw agent — CLI chat interface │
│ zeroclaw daemon — Autonomous runtime │
│ (systemd-managed) │
│ zeroclaw gateway — Webhook server │
│ (127.0.0.1:42617) │
│ + Web dashboard (:3000) │
├──────────────────────────────────────────────┤
│ Tokio async runtime (work-stealing executor) │
│ ~7 threads per bot (vs ~20+ for OpenClaw) │
├──────────────────────────────────────────────┤
│ SQLite + vector search (70/30 hybrid) │
│ ChaCha20-Poly1305 encryption at rest │
│ Arena allocation, ownership-based safety │
└──────────────────────────────────────────────┘Workspace: ~/.zeroclaw/workspace/ containing sessions, memory, state, cron jobs, skills, and identity files (IDENTITY.md, AGENTS.md, SOUL.md, TOOLS.md).
Trait-driven design: Providers, memory backends, tools, channels, and tunnels are all swappable via Rust traits — no vendor lock-in at the type level.
Security Model
ZeroClaw's security thesis: eliminate entire vulnerability classes at compile time via Rust's ownership system, then encrypt everything at rest.
Five-layer security:
| Layer | Mechanism |
|---|---|
| Network | Binds to 127.0.0.1 by default, rate limiting, 64KB body limit |
| Authentication | 6-digit OTP pairing-based verification |
| Authorization | Three autonomy levels, command allowlists, domain restrictions |
| Runtime | Optional Docker sandbox, read-only rootfs, memory/CPU limits |
| Data | ChaCha20-Poly1305 encryption at rest; secrets never in env vars |
Rust-inherent safety: The ownership system eliminates buffer overflows, use-after-free, and data races at compile time. These are vulnerability classes that have historically generated CVEs across systems software. OpenClaw has 9+ CVEs; ZeroClaw has zero.
"Sovereign" mode: All API keys remain local. No external orchestration service is contacted.
Honest limitation: Hacker News security researchers consider the approach "naive" for focusing on access control without adequately addressing prompt injection and AI behavioral manipulation.
LLM Support (22+ Providers)
| Provider | Notes |
|---|---|
| Anthropic / Claude | API key and auth token |
| OpenAI | Including Codex with OAuth |
| Google Gemini | Full support |
| OpenRouter | Multi-model gateway |
| GitHub Copilot | Via API |
| DeepSeek, Qwen, Groq | Supported |
| Ollama, LM Studio | Local models |
| Any OpenAI-compatible endpoint | Via custom config |
This is ZeroClaw's biggest advantage over NanoClaw — true model-agnostic support with 22+ providers out of the box.
Messaging Platforms (30+ Channels)
| Platform | Status |
|---|---|
| Telegram | Built-in, with voice |
| Discord | Built-in |
| Slack | Built-in |
| Matrix | Built-in, with E2EE |
| WhatsApp Web | Requires --features whatsapp-web compile flag; not in default binary |
| CLI | Built-in |
Plus 70+ integrations referenced in documentation. The WhatsApp caveat is significant — it's not in the default release binary and lacks media attachment support.
Capabilities
Core:
- Multi-channel messaging with persistent memory (SQLite + vector search)
- Cron-style scheduler for recurring tasks
- Web search and page fetching (with domain restrictions)
- HTTP request tools
- GPIO/hardware control (LEDs, sensors, motors, relays)
- Agent orchestration and autonomous execution
- Observability: Prometheus, OpenTelemetry, structured logging
zeroclaw migrate openclawfor migration from OpenClaw
Notable absences: Native file management, shell access, calendar, email, and smart home integrations are not documented as built-in. These require custom tool implementation.
Performance
This is where ZeroClaw dominates:
| Metric | ZeroClaw | OpenClaw | NanoClaw (host) |
|---|---|---|---|
| Idle RAM | ~4 MB | ~1.2 GB | ~150 MB |
| Peak heap | ~12 MB | ~320 MB | ~200 MB + containers |
| Cold start | <10 ms | 500ms–8s | ~500ms + container startup |
| Binary size | 3.4 MB | 298 MB–2.5 GB | ~50 MB (node_modules) |
| Threads per bot | ~7 | ~20+ | ~10 + container overhead |
| Throughput | 450 tasks/sec | 120 tasks/sec | ~100 tasks/sec |
| Bots on same hardware | 50–100 | 4–5 | 10–15 |
ZeroClaw uses 300x less RAM than OpenClaw at idle. On a Raspberry Pi 4 (4GB), you can run 50–100 ZeroClaw bots versus 4–5 OpenClaw bots.
Setup
# Homebrew
brew install zeroclaw
# Or one-line install
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/install.sh | bash
# Or cargo
cargo build --release --lockedThen:
zeroclaw onboard --interactive # 11-step wizard
# or
zeroclaw onboard --api-key sk-... --provider openrouterPlatform support:
- Tier 1 (fully tested): Linux (Ubuntu 20.04+, Debian 11+, Fedora 35+), Windows 10/11, macOS 11+
- Tier 2 (community-validated): Raspberry Pi OS, Alpine Linux (ARMv7/AArch64)
Community
- 27.6k stars, 3.7k forks
- Contributors from Harvard, MIT, Sundai.Club
- Releases every 1–2 days
- Active on X (@zeroclawlabs), Reddit (r/zeroclawlabs)
- Website and Discord under development
- Warning: Official only via GitHub — beware impersonation from zeroclaw.org/.net
ZeroClaw：Rust 效能純粹主義者
架構
ZeroClaw 是一個單一編譯的 Rust 二進位檔。沒有 Node.js、沒有 Python、沒有 runtime 直譯器。三個獨立服務：
┌──────────────────────────────────────────────┐
│ zeroclaw agent — CLI 聊天介面 │
│ zeroclaw daemon — 自主 runtime │
│ （systemd 管理） │
│ zeroclaw gateway — Webhook 伺服器 │
│ （127.0.0.1:42617） │
│ + Web 儀表板（:3000） │
├──────────────────────────────────────────────┤
│ Tokio 非同步 runtime（work-stealing 執行器） │
│ 每個 bot 約 7 個執行緒（OpenClaw 需 20+） │
├──────────────────────────────────────────────┤
│ SQLite + 向量搜尋（70/30 混合） │
│ ChaCha20-Poly1305 靜態加密 │
│ Arena 分配，所有權型安全 │
└──────────────────────────────────────────────┘工作區： ~/.zeroclaw/workspace/ 包含 session、記憶、狀態、cron 任務、skill 和身份檔案（IDENTITY.md、AGENTS.md、SOUL.md、TOOLS.md）。
Trait 驅動設計： Provider、記憶後端、工具、頻道和通道都可以透過 Rust trait 替換——在型別層級沒有廠商鎖定。
安全模型
ZeroClaw 的安全論點：在編譯時透過 Rust 所有權系統消除整個漏洞類別，然後加密一切靜態資料。
五層安全：
| 層 | 機制 |
|---|---|
| 網路 | 預設綁定 127.0.0.1，速率限制，64KB body 限制 |
| 認證 | 6 位數 OTP 配對驗證 |
| 授權 | 三個自主等級、指令白名單、網域限制 |
| Runtime | 選用 Docker sandbox、唯讀 rootfs、記憶體/CPU 限制 |
| 資料 | ChaCha20-Poly1305 靜態加密；secret 絕不存在環境變數中 |
Rust 固有安全： 所有權系統在編譯時消除 buffer overflow、use-after-free 和 data race。這些是歷史上在系統軟體中產生 CVE 的漏洞類別。OpenClaw 有 9+ 個 CVE；ZeroClaw 有零個。
「Sovereign」模式： 所有 API key 保持在本地。不會聯繫外部編排服務。
誠實的限制： Hacker News 上的安全研究者認為這種方式「天真」，因為它專注於存取控制而沒有充分解決 prompt injection 和 AI 行為操縱問題。
LLM 支援（22+ Provider）
| Provider | 備註 |
|---|---|
| Anthropic / Claude | API key 和 auth token |
| OpenAI | 包括 Codex（OAuth） |
| Google Gemini | 完整支援 |
| OpenRouter | 多模型 gateway |
| GitHub Copilot | 透過 API |
| DeepSeek、Qwen、Groq | 支援 |
| Ollama、LM Studio | 本地模型 |
| 任何 OpenAI 相容端點 | 透過自訂設定 |
這是 ZeroClaw 對 NanoClaw 最大的優勢——真正的模型不可知支援，開箱即用 22+ 個 provider。
訊息平台（30+ 頻道）
| 平台 | 狀態 |
|---|---|
| Telegram | 內建，含語音 |
| Discord | 內建 |
| Slack | 內建 |
| Matrix | 內建，含 E2EE |
| WhatsApp Web | 需要 --features whatsapp-web 編譯旗標；不在預設二進位檔中 |
| CLI | 內建 |
文件中參考了 70+ 個整合。WhatsApp 的但書很重要——它不在預設 release 二進位檔中，且缺少媒體附件支援。
能力
核心：
- 多頻道訊息，搭配持久化記憶（SQLite + 向量搜尋）
- Cron 排程器用於循環任務
- Web 搜尋和頁面擷取（有網域限制）
- HTTP 請求工具
- GPIO/硬體控制（LED、感測器、馬達、繼電器）
- Agent 編排與自主執行
- 可觀察性：Prometheus、OpenTelemetry、結構化日誌
zeroclaw migrate openclaw從 OpenClaw 遷移
值得注意的缺失： 原生檔案管理、shell 存取、日曆、email 和智慧家庭整合沒有被記錄為內建功能。這些需要自訂工具實作。
效能
這是 ZeroClaw 稱霸的地方：
| 指標 | ZeroClaw | OpenClaw | NanoClaw（主機） |
|---|---|---|---|
| 閒置 RAM | 約 4 MB | 約 1.2 GB | 約 150 MB |
| 峰值 heap | 約 12 MB | 約 320 MB | 約 200 MB + 容器 |
| 冷啟動 | <10 ms | 500ms–8s | 約 500ms + 容器啟動 |
| 二進位大小 | 3.4 MB | 298 MB–2.5 GB | 約 50 MB（node_modules） |
| 每 bot 執行緒 | 約 7 | 約 20+ | 約 10 + 容器開銷 |
| 吞吐量 | 450 tasks/sec | 120 tasks/sec | 約 100 tasks/sec |
| 同硬體 bot 數 | 50–100 | 4–5 | 10–15 |
ZeroClaw 閒置時使用比 OpenClaw 少 300 倍的 RAM。在 Raspberry Pi 4（4GB）上，你可以跑 50–100 個 ZeroClaw bot，而 OpenClaw 只能跑 4–5 個。
安裝
# Homebrew
brew install zeroclaw
# 或一行安裝
curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/master/install.sh | bash
# 或 cargo
cargo build --release --locked然後：
zeroclaw onboard --interactive # 11 步精靈
# 或
zeroclaw onboard --api-key sk-... --provider openrouter平台支援：
- Tier 1（完整測試）：Linux（Ubuntu 20.04+、Debian 11+、Fedora 35+）、Windows 10/11、macOS 11+
- Tier 2（社群驗證）：Raspberry Pi OS、Alpine Linux（ARMv7/AArch64）
社群
- 27.6k 星、3.7k fork
- 來自 Harvard、MIT、Sundai.Club 的貢獻者
- 每 1–2 天發佈
- 活躍於 X（@zeroclawlabs）、Reddit（r/zeroclawlabs）
- 網站和 Discord 開發中
- 注意：僅 GitHub 為官方——小心 zeroclaw.org/.net 的冒充
Head-to-Head Comparison
Security
| Dimension | NanoClaw | ZeroClaw |
|---|---|---|
| Isolation model | OS-level containers (each group gets own container) | Language-level (Rust ownership) + optional Docker |
| Attack surface | ~3,900 lines auditable + container runtime | 3.4 MB binary, <1% unsafe code |
| Secret storage | Env vars (stdin-passed, never on disk) | ChaCha20-Poly1305 encrypted at rest |
| CVEs | 0 (too new to tell) | 0 (Rust eliminates common vulnerability classes) |
| Prompt injection defense | Container limits blast radius | Domain restrictions + command allowlists |
| Supply chain risk | No marketplace (by design) | No marketplace (by design) |
| Docker partnership | Yes (Docker Sandboxes, hypervisor-level) | No |
Verdict: NanoClaw has stronger architectural isolation (every group in its own container). ZeroClaw has stronger language-level safety (Rust eliminates entire bug classes). Neither fully solves prompt injection.
Performance
| Metric | NanoClaw | ZeroClaw | Winner |
|---|---|---|---|
| Host RAM | ~150 MB | ~4 MB | ZeroClaw (37x) |
| Cold start | ~500ms + container | <10 ms | ZeroClaw (50x+) |
| Binary/install size | ~50 MB | 3.4 MB | ZeroClaw (15x) |
| Bots per 4GB device | 10–15 | 50–100 | ZeroClaw (5–7x) |
| Throughput | ~100 tasks/sec | 450 tasks/sec | ZeroClaw (4.5x) |
Verdict: ZeroClaw wins every performance metric. It's not close.
Capabilities
| Capability | NanoClaw | ZeroClaw |
|---|---|---|
| Built-in, first-class | Requires custom compilation | |
| Telegram | Via skill | Built-in |
| Discord | Built-in | Built-in |
| Slack | Built-in | Built-in |
| Matrix (E2EE) | No | Built-in |
| Gmail | Via skill | Not built-in |
| Smart Home | Via skill (Home Assistant) | GPIO only (raw hardware) |
| Agent Browser | Via skill | Not built-in |
| Voice transcription | Via skill (Whisper) | Via Telegram voice |
| Agent swarms | Native (first claw to support) | Not documented |
| LLM providers | Claude-optimized (~1 native) | 22+ providers |
| Scheduled tasks | Built-in | Built-in (cron) |
| Observability | Basic | Prometheus, OpenTelemetry |
Verdict: NanoClaw has more consumer-friendly features (WhatsApp, Gmail, Smart Home, browser). ZeroClaw has broader LLM support and better observability.
Developer Experience
| Aspect | NanoClaw | ZeroClaw |
|---|---|---|
| Setup time | Minutes (AI-guided) | Minutes (wizard or one-liner) |
| Config files | 0 (AI-native) | 1 (TOML) |
| Customization | Tell Claude what you want | Edit TOML or implement Rust traits |
| Plugin model | Skills (AI modifies source code) | Rust traits (compile-in) |
| Migration from OpenClaw | Manual | zeroclaw migrate openclaw built-in |
| Codebase readability | 8 minutes to read everything | Requires Rust expertise |
| Adding custom tools | Ask Claude to add it | Implement Rust trait + recompile |
Verdict: NanoClaw is radically easier to customize (just talk to Claude). ZeroClaw requires Rust knowledge but offers a proper migration path from OpenClaw.
正面對決
安全
| 維度 | NanoClaw | ZeroClaw |
|---|---|---|
| 隔離模型 | 作業系統層級容器（每群組一個容器） | 語言層級（Rust 所有權）+ 選用 Docker |
| 攻擊面 | 約 3,900 行可審計 + 容器 runtime | 3.4 MB 二進位檔，<1% unsafe 程式碼 |
| Secret 儲存 | 環境變數（stdin 傳遞，不落磁碟） | ChaCha20-Poly1305 靜態加密 |
| CVE | 0（太新還看不出來） | 0（Rust 消除常見漏洞類別） |
| Prompt injection 防禦 | 容器限制爆炸半徑 | 網域限制 + 指令白名單 |
| 供應鏈風險 | 沒有 marketplace（設計決策） | 沒有 marketplace（設計決策） |
| Docker 合作 | 是（Docker Sandboxes，hypervisor 層級） | 否 |
結論： NanoClaw 有更強的架構隔離（每個群組在自己的容器中）。ZeroClaw 有更強的語言層級安全（Rust 消除整個 bug 類別）。兩者都沒有完全解決 prompt injection。
效能
| 指標 | NanoClaw | ZeroClaw | 勝者 |
|---|---|---|---|
| 主機 RAM | 約 150 MB | 約 4 MB | ZeroClaw（37 倍） |
| 冷啟動 | 約 500ms + 容器 | <10 ms | ZeroClaw（50 倍以上） |
| 二進位/安裝大小 | 約 50 MB | 3.4 MB | ZeroClaw（15 倍） |
| 每 4GB 設備 bot 數 | 10–15 | 50–100 | ZeroClaw（5–7 倍） |
| 吞吐量 | 約 100 tasks/sec | 450 tasks/sec | ZeroClaw（4.5 倍） |
結論： ZeroClaw 贏得每一個效能指標。差距不小。
能力
| 能力 | NanoClaw | ZeroClaw |
|---|---|---|
| 內建，一級支援 | 需自訂編譯 | |
| Telegram | 透過 skill | 內建 |
| Discord | 內建 | 內建 |
| Slack | 內建 | 內建 |
| Matrix（E2EE） | 無 | 內建 |
| Gmail | 透過 skill | 非內建 |
| Smart Home | 透過 skill（Home Assistant） | 僅 GPIO（原始硬體） |
| Agent Browser | 透過 skill | 非內建 |
| 語音轉錄 | 透過 skill（Whisper） | 透過 Telegram 語音 |
| Agent swarm | 原生（第一個支援的 claw） | 未記錄 |
| LLM provider | Claude 優化（約 1 個原生） | 22+ provider |
| 排程任務 | 內建 | 內建（cron） |
| 可觀察性 | 基本 | Prometheus、OpenTelemetry |
結論： NanoClaw 有更多消費者友善功能（WhatsApp、Gmail、Smart Home、瀏覽器）。ZeroClaw 有更廣的 LLM 支援和更好的可觀察性。
開發者體驗
| 面向 | NanoClaw | ZeroClaw |
|---|---|---|
| 設定時間 | 幾分鐘（AI 引導） | 幾分鐘（精靈或一行指令） |
| 設定檔 | 0（AI 原生） | 1（TOML） |
| 自訂 | 告訴 Claude 你想要什麼 | 編輯 TOML 或實作 Rust trait |
| Plugin 模型 | Skill（AI 修改原始碼） | Rust trait（編譯進去） |
| 從 OpenClaw 遷移 | 手動 | 內建 zeroclaw migrate openclaw |
| Codebase 可讀性 | 8 分鐘讀完一切 | 需要 Rust 專業知識 |
| 新增自訂工具 | 叫 Claude 加上去 | 實作 Rust trait + 重新編譯 |
結論： NanoClaw 自訂起來激進地簡單（跟 Claude 說就好）。ZeroClaw 需要 Rust 知識，但提供從 OpenClaw 遷移的正式路徑。
When to Choose NanoClaw
Choose NanoClaw if:
WhatsApp is your primary channel — NanoClaw has the strongest WhatsApp integration. ZeroClaw requires custom compilation and lacks media attachments.
You want the strongest architectural isolation — Every chat group gets its own container with its own kernel (Docker Sandboxes). A compromised agent in Group A cannot access Group B's data.
You're a Claude-only user — If you exclusively use Anthropic's Claude, NanoClaw's Claude-optimized design is a feature, not a limitation.
You want to customize without coding — NanoClaw's "AI-native" approach means you tell Claude Code what you want and it modifies the codebase. No config files, no Rust compilation.
You need agent swarms — NanoClaw is the first claw platform to support multi-agent collaboration with individual bot identities (Telegram Swarm).
You care about auditability — 3,900 lines. 15 files. One sitting. You can personally verify every line of code that touches your data.
You want smart home control — Home Assistant integration via skill. ZeroClaw only has raw GPIO.
NanoClaw sweet spot: Personal WhatsApp/Telegram assistant for someone who uses Claude, wants strong security guarantees, and values simplicity over breadth.
什麼時候選 NanoClaw
在以下情況選擇 NanoClaw：
WhatsApp 是你的主要頻道 —— NanoClaw 有最強的 WhatsApp 整合。ZeroClaw 需要自訂編譯且缺少媒體附件支援。
你想要最強的架構隔離 —— 每個聊天群組有自己的容器和自己的 kernel（Docker Sandboxes）。Group A 中被入侵的 agent 無法存取 Group B 的資料。
你只用 Claude —— 如果你專門使用 Anthropic 的 Claude，NanoClaw 的 Claude 優化設計是功能，不是限制。
你想不寫程式碼就自訂 —— NanoClaw 的「AI 原生」方式意味著你告訴 Claude Code 你想要什麼，它就修改 codebase。沒有設定檔，不用編譯 Rust。
你需要 agent swarm —— NanoClaw 是第一個支援多 agent 協作、各有獨立 bot 身份的 claw 平台（Telegram Swarm）。
你在意可審計性 —— 3,900 行。15 個檔案。一次坐下來就能讀完。你可以親自驗證每一行碰到你資料的程式碼。
你想要智慧家庭控制 —— 透過 skill 整合 Home Assistant。ZeroClaw 只有原始 GPIO。
NanoClaw 最佳場景： 給使用 Claude、想要強安全保障、重視簡潔勝過廣度的人，做為個人 WhatsApp/Telegram 助手。
When to Choose ZeroClaw
Choose ZeroClaw if:
You need to run on constrained hardware — Raspberry Pi, edge devices, IoT boards. 4 MB RAM and 3.4 MB binary. NanoClaw needs Docker + Node.js, which is heavy for a Pi Zero.
You want model freedom — 22+ LLM providers out of the box. Switch between Claude, GPT, Gemini, DeepSeek, Qwen, local Ollama models without middleware.
You're hosting many bots — 50–100 concurrent bots on the same hardware. NanoClaw tops out at 10–15. If you're running a service for multiple users, ZeroClaw's density is unbeatable.
Matrix with E2EE is important — Built-in Matrix support with end-to-end encryption. NanoClaw doesn't have this.
You're migrating from OpenClaw —
zeroclaw migrate openclawconverts configs automatically. NanoClaw requires manual migration.You need production observability — Prometheus metrics, OpenTelemetry tracing, structured logging built in. NanoClaw has only basic diagnostics.
You want encrypted secrets at rest — ZeroClaw encrypts all secrets with ChaCha20-Poly1305. NanoClaw passes secrets via stdin/env vars.
You're comfortable with Rust — Adding custom tools means implementing Rust traits and recompiling. If you know Rust, this is powerful. If you don't, it's a wall.
ZeroClaw sweet spot: Multi-bot deployment on resource-constrained or edge hardware, for someone who values LLM flexibility and production-grade observability.
什麼時候選 ZeroClaw
在以下情況選擇 ZeroClaw：
你需要在受限硬體上運行 —— Raspberry Pi、邊緣設備、IoT 開發板。4 MB RAM 和 3.4 MB 二進位檔。NanoClaw 需要 Docker + Node.js，對 Pi Zero 來說太重了。
你想要模型自由 —— 開箱即用 22+ 個 LLM provider。在 Claude、GPT、Gemini、DeepSeek、Qwen、本地 Ollama 模型之間切換，不需要中介軟體。
你要託管很多 bot —— 同一硬體上 50–100 個並行 bot。NanoClaw 上限是 10–15 個。如果你為多個使用者運行服務，ZeroClaw 的密度無可匹敵。
Matrix 加 E2EE 很重要 —— 內建 Matrix 支援，含端對端加密。NanoClaw 沒有這個。
你正在從 OpenClaw 遷移 ——
zeroclaw migrate openclaw自動轉換設定。NanoClaw 需要手動遷移。你需要 production 可觀察性 —— 內建 Prometheus metrics、OpenTelemetry tracing、結構化日誌。NanoClaw 只有基本診斷。
你想要靜態加密的 secret —— ZeroClaw 用 ChaCha20-Poly1305 加密所有 secret。NanoClaw 透過 stdin/env var 傳遞 secret。
你對 Rust 熟悉 —— 新增自訂工具意味著實作 Rust trait 並重新編譯。如果你懂 Rust，這很強大。如果不懂，這是一堵牆。
ZeroClaw 最佳場景： 在資源受限或邊緣硬體上的多 bot 部署，適合重視 LLM 靈活性和 production 等級可觀察性的人。
The Maturity Warning (Both Projects)
Both projects are extremely young:
| NanoClaw | ZeroClaw | |
|---|---|---|
| Age | ~7 weeks | ~13 months |
| Version | No semver (tracks codebase size) | v0.1.6 |
| Integration tests | Not documented | 3 |
| Known code quality issues | Markdown code block bug in skills | 261 .unwrap() calls across 80 files |
| Enterprise features | None (no SSO, RBAC, audit logging) | None |
| Horizontal scaling | Single-node only | Single-node only |
Practical advice:
- Don't run either in production for critical business workflows yet
- Back up your data — both store state locally (
~/.nanoclaw/or~/.zeroclaw/) - Pin versions — both are releasing at breakneck speed
- Monitor agent behavior — neither has solved prompt injection
- Start with one bot — observe before scaling
成熟度警告（兩個專案）
兩個專案都極度年輕：
| NanoClaw | ZeroClaw | |
|---|---|---|
| 年齡 | 約 7 週 | 約 13 個月 |
| 版本 | 無 semver（追蹤 codebase 大小） | v0.1.6 |
| 整合測試 | 未記錄 | 3 個 |
| 已知程式碼品質問題 | Skill 中的 Markdown code block bug | 80 個檔案中有 261 個 .unwrap() 呼叫 |
| 企業功能 | 無（沒有 SSO、RBAC、稽核日誌） | 無 |
| 水平擴展 | 僅單節點 | 僅單節點 |
實用建議：
- 還不要在關鍵業務工作流中用於 production
- 備份你的資料 —— 兩者都在本地儲存狀態（
~/.nanoclaw/或~/.zeroclaw/） - 鎖定版本 —— 兩者都在飛速發佈
- 監控 agent 行為 —— 兩者都沒有解決 prompt injection
- 從一個 bot 開始 —— 觀察後再擴展
Decision Flowchart
Is WhatsApp your primary channel?
├── Yes → NanoClaw
└── No
├── Running on Raspberry Pi or edge hardware?
│ ├── Yes → ZeroClaw
│ └── No
│ ├── Need 22+ LLM providers?
│ │ ├── Yes → ZeroClaw
│ │ └── No (Claude-only)
│ │ ├── Need agent swarms?
│ │ │ ├── Yes → NanoClaw
│ │ │ └── No
│ │ │ ├── Value auditability over features?
│ │ │ │ ├── Yes → NanoClaw
│ │ │ │ └── No → ZeroClaw
│ │ │ └──
│ │ └──
│ └──
└──Both are legitimate, well-engineered projects with growing communities. The "right" choice depends entirely on your priorities: isolation and simplicity (NanoClaw) or performance and flexibility (ZeroClaw).
決策流程圖
WhatsApp 是你的主要頻道嗎？
├── 是 → NanoClaw
└── 否
├── 在 Raspberry Pi 或邊緣硬體上運行？
│ ├── 是 → ZeroClaw
│ └── 否
│ ├── 需要 22+ 個 LLM provider？
│ │ ├── 是 → ZeroClaw
│ │ └── 否（只用 Claude）
│ │ ├── 需要 agent swarm？
│ │ │ ├── 是 → NanoClaw
│ │ │ └── 否
│ │ │ ├── 重視可審計性勝過功能？
│ │ │ │ ├── 是 → NanoClaw
│ │ │ │ └── 否 → ZeroClaw
│ │ │ └──
│ │ └──
│ └──
└──兩者都是合法、工程品質良好、社群持續成長的專案。「正確」的選擇完全取決於你的優先順序：隔離與簡潔（NanoClaw）或效能與靈活性（ZeroClaw）。