ZeroClaw and the *-claw Ecosystem: A Factual Comparison
Posted 2026-11-04 · by han · 15 min read
A grounded, source-backed comparison of the personal-AI-agent projects that share the "-claw" name — OpenClaw, ZeroClaw, IronClaw, NanoClaw, NullClaw, MicroClaw, PicoClaw (upstream and fork), NemoClaw, and TinyClaw/TinyAGI. No opinion; every number traced to a GitHub repo page [as of 2026-11-04].
TL;DR
- The "-claw" family is a loose ecosystem of personal AI agent runtimes that grew out of OpenClaw (the originator, ~394k ⭐). Most are independent rewrites in other languages targeting smaller footprints or stronger isolation.
- ZeroClaw (Rust, ~33.1k ⭐) is one of the larger Rust rewrites: single binary, 30+ channels, ~20 providers, hardware GPIO/I2C/SPI, an SOP engine, ACP.
- NemoClaw is not a standalone agent — it's an NVIDIA sandbox wrapper (OpenShell) that runs OpenClaw/Hermes/DeepAgents more safely. Counting it as an "agent" is a category error.
- PicoClaw has two distinct repos: upstream
sipeed/picoclaw(~30.1k ⭐) and an active forkafjcjsbx/picoclaw(47 ⭐). They must not be conflated. - NullClaw's benchmark table (RAM/startup/binary size vs. OpenClaw, NanoBot, PicoClaw, ZeroClaw) is project-self-reported [project-reported, NullClaw, Feb 2026]. Treat as marketing, not measurement.
- NullClaw itself grew from 1.8k (plan-era guess) to 8.2k ⭐ [as of 2026-11-04] — verify star counts on the live page before quoting.
1. What this family is
"Claw" projects are personal AI assistants you run yourself: they talk to LLM providers, reach you over chat channels (Telegram, Discord, Slack, …), and act through tools (shell, browser, files, hardware). The common thread is ownership — your keys, your data, your machine. Beyond that, they diverge sharply on language, size, isolation model, and target hardware.
OpenClaw is the originator and the largest by a wide margin. The others are mostly rewrites that trade OpenClaw's breadth for a smaller footprint, a different language, or a stricter sandbox.
2. The vendors (snapshot [as of 2026-11-04])
| Project | Org / Vendor | Language | Stars | Forks | Commits | License | What it is |
|---|---|---|---|---|---|---|---|
| OpenClaw | openclaw | TypeScript (Node) | 393.8k | 82.8k | 124,906 | MIT | Originator. "The AI that really does things." |
| ZeroClaw | zeroclaw-labs | Rust | 33.1k | 5.0k | 5,803 | MIT OR Apache-2.0 | Single Rust binary; 30+ channels, ~20 providers, ACP, SOP engine, hardware GPIO/I2C/SPI |
| IronClaw | nearai (NEAR AI) | Rust | 12.7k | 1.5k | 4,073 | MIT OR Apache-2.0 | "Agent OS" focused on privacy/security; WASM sandbox, Postgres, OpenClaw reimpl |
| NanoClaw | nanocoai | TypeScript (Node) | 31.1k | 12.7k | 3,054 | MIT | Lightweight OpenClaw alt; agents run in Linux containers; Claude Agent SDK |
| NullClaw | nullclaw | Zig | 8.2k | 960 | 2,837 | MIT | "Smallest fully autonomous" agent; 678 KB static binary, ~1 MB RAM, <2 ms startup |
| MicroClaw | microclaw | Rust | 751 | 139 | 1,268 | MIT | Server + native Work desktop app + embeddable Rust SDK; durable delivery |
| PicoClaw (upstream) | sipeed | Go | 30.1k | 4.4k | 2,584 | MIT | Ultra-lightweight, IoT/SBC target, $10 hardware |
| PicoClaw (fork) | afjcjsbx | Go | 47 | 14 | 3,275 | MIT | "Actively maintained fork" with WebUI, MCP, plugins, chat apps |
| NemoClaw | NVIDIA | TypeScript (CLI) | 22.9k | 3.2k | 6,351 | Apache-2.0 | Sandbox wrapper (OpenShell) for OpenClaw/Hermes/DeepAgents — not a standalone agent |
| TinyClaw / TinyAGI | TinyAGI | TypeScript (Node) | 3.6k | 505 | 198 | MIT | Multi-agent team orchestrator (renamed from TinyClaw to TinyAGI) |
Notes on counts: star/fork/commit figures are snapshots [as of 2026-11-04] from each repo's GitHub page; they drift daily. Do not quote without the date.
NullHub (nullclaw/nullhub, 1.8k ⭐) is a separate management console for the Null ecosystem (install/configure/monitor NullClaw, NullBoiler, NullTickets, NullWatch) — not an agent itself.
3. Comparison dimensions
3.1 Language & runtime
| Project | Language | Runtime model |
|---|---|---|
| OpenClaw | TypeScript | Node.js (single process, shared memory) |
| ZeroClaw | Rust | Single static binary |
| IronClaw | Rust | Rust binary + WebUI; Postgres persistence |
| NanoClaw | TypeScript (Node) | Host process + per-agent Docker containers |
| NullClaw | Zig | Static binary, zero runtime (libc only) |
| MicroClaw | Rust | Server service + native GPUI desktop app + SDK |
| PicoClaw | Go | Single binary (cross-compiled to RISC-V/ARM/MIPS/x86) |
| NemoClaw | TypeScript (CLI) | Host CLI driving OpenShell sandboxes |
| TinyAGI | TypeScript (Node) | Node orchestrator + SQLite queue + claude/codex CLIs |
3.2 Binary size / RAM / startup
Only NullClaw publishes a controlled-ish comparison table. It compares OpenClaw, NanoBot, PicoClaw, ZeroClaw, and itself. This table is project-self-reported by NullClaw [project-reported, NullClaw, Feb 2026, macOS arm64, normalized to 0.8 GHz edge hardware]. Treat as indicative, not benchmarked truth.
| Metric | OpenClaw | NanoBot | PicoClaw | ZeroClaw | NullClaw |
|---|---|---|---|---|---|
| Language | TypeScript | Python | Go | Rust | Zig |
| RAM | > 1 GB | > 100 MB | < 10 MB | < 5 MB | ~1 MB |
| Startup (0.8 GHz) | > 500 s | > 30 s | < 1 s | < 10 ms | < 8 ms |
| Binary size | ~28 MB (dist) | N/A (scripts) | ~8 MB | ~8.8 MB | 678 KB |
| Tests | — | — | — | 1,017 | 5,300+ |
| Source files | ~400+ | — | — | ~120 | ~230 |
| Cost target | Mac Mini $599 | Linux SBC ~$50 | Linux board $10 | Any $10 hardware | Any $5 hardware |
Important caveats:
- ZeroClaw's own README does not state a binary size or RAM figure; the "~8.8 MB / <5 MB / <10 ms" above comes from NullClaw's comparison, not from ZeroClaw's docs [project-reported by NullClaw].
- PicoClaw's own README claims "<10 MB RAM" but its fork's more recent measurements report 10–20 MB RAM and a 48.1 MiB full default macOS ARM64 binary (idle RSS 37.9 MiB, ~19 MiB phys_footprint) [project-reported, afjcjsbx fork, 2026-10-26]. The upstream
sipeedREADME still says "<10MB." These are different builds/timeframes — do not mix. - NullClaw's "678 KB / ~1 MB RAM / <2 ms" is NullClaw's own measurement on ReleaseSmall builds (
/usr/bin/time -l) [project-reported].
3.3 License
| Project | License |
|---|---|
| OpenClaw | MIT |
| ZeroClaw | MIT OR Apache-2.0 (dual) |
| IronClaw | MIT OR Apache-2.0 (dual) |
| NanoClaw | MIT |
| NullClaw | MIT |
| MicroClaw | MIT |
| PicoClaw (upstream & fork) | MIT |
| NemoClaw | Apache-2.0 |
| TinyAGI | MIT |
ZeroClaw, IronClaw, and NemoClaw are the only ones with Apache-2.0 involvement; the rest are MIT-only. None of the MIT-only projects require a CLA; ZeroClaw and IronClaw ask contributors to grant both licenses (see their CLA docs).
3.4 Provider count
| Project | Providers | Source |
|---|---|---|
| NullClaw | 50+ (OpenRouter, Anthropic, OpenAI, Azure, Gemini, Vertex, Ollama, Venice, NEAR AI Cloud, Atlas Cloud, Evolink, Eden AI, Groq, Mistral, xAI, DeepSeek, Together, Fireworks, Perplexity, Cohere, Bedrock, …) | README architecture table |
| ZeroClaw | ~20 (Anthropic, OpenAI, Ollama, and ~20 others) | README |
| PicoClaw | 30+ (OpenAI, Anthropic, Gemini, OpenRouter, Zhipu, DeepSeek, Volcengine, Qwen, Groq, Moonshot, Minimax, Mistral, NVIDIA NIM, Cerebras, NEAR AI, Novita, Xiaomi MiMo, Ollama, vLLM, LiteLLM, Azure, GitHub Copilot, Antigravity, AWS Bedrock, …) | README provider table |
| NanoClaw | Claude Agent SDK native; OpenAI Codex, OpenRouter/Google/DeepSeek via OpenCode, Cursor, Ollama via skills | README |
| MicroClaw | Anthropic native; OpenAI/OpenRouter/Ollama/Google/DeepSeek/… via OpenAI-compatible path | README |
| IronClaw | LLM providers via onboard; not enumerated with counts in README | — |
| OpenClaw | Not enumerated with counts in README | — |
| NemoClaw | Inference routed via OpenShell; provider chosen at onboarding | — |
| TinyAGI | Anthropic (Claude), OpenAI (Codex), custom OpenAI/Anthropic-compatible endpoints | README |
3.5 Channel count
| Project | Channels |
|---|---|
| NullClaw | 19 (CLI, Telegram, Signal, Discord, Slack, iMessage, Matrix, WhatsApp, Webhook, IRC, Lark/Feishu, OneBot, Line, DingTalk, Email, Nostr, QQ, MaixCam, Mattermost) |
| ZeroClaw | 30+ (Discord, Telegram, Matrix, email, voice, webhooks, CLI, ACP, …) |
| PicoClaw | 19+ (Telegram, Discord, WhatsApp, Weixin, QQ, Slack, Matrix, Delta Chat, DingTalk, Feishu/Lark, LINE, WeCom, VK, IRC, OneBot, MQTT, MaixCam, Pico, Pico Client) |
| NanoClaw | WhatsApp, Telegram, Discord, Slack, MS Teams, iMessage, Matrix, Google Chat, Webex, Linear, GitHub, WeChat, email (via Resend) — installed on demand via skills |
| MicroClaw | Telegram, Discord, Slack, Feishu/Lark, WeChat, DingTalk, QQ, WhatsApp, Signal, Matrix, IRC, Nostr, iMessage, email, Web |
| IronClaw | REPL, HTTP webhooks, WASM channels (Telegram, Slack), web gateway |
| OpenClaw | Not enumerated in README |
| NemoClaw | Inherited from the wrapped agent |
| TinyAGI | Discord, WhatsApp, Telegram |
3.6 Memory system
| Project | Memory approach |
|---|---|
| OpenClaw | Not detailed in README (markdown identity files mentioned by IronClaw's comparison) |
| ZeroClaw | SQLite + embeddings (per architecture diagram: "memory (SQLite, embeddings)") |
| IronClaw | Hybrid FTS + vector search (Reciprocal Rank Fusion); workspace filesystem; identity files |
| NanoClaw | Per-agent CLAUDE.md + memory; scheduled tasks; container-mounted folders |
| NullClaw | 10 memory engines (SQLite with FTS5+vector cosine, Markdown, ClickHouse, PostgreSQL, Redis, LanceDB, Lucid, LRU, API, None); hybrid search; hygiene; snapshots |
| MicroClaw | File + SQLite memory, semantic recall, temporal knowledge graph, experience evidence, governed skill evolution |
| PicoClaw | JSONL memory store (v0.2.1+); "Seahorse" built-in (SQLite + FTS5 over session history) in the fork; Mem0 plugin support |
| NemoClaw | Inherited from wrapped agent |
| TinyAGI | Persistent sessions via SQLite queue; per-agent workspaces |
3.7 Security model
| Project | Isolation approach |
|---|---|
| OpenClaw | Application-level (allowlists, pairing codes); everything in one Node process with shared memory (NanoClaw's critique) |
| ZeroClaw | Supervised autonomy default; workspace boundaries, command policy, OS sandboxes (Landlock/Bubblewrap/Seatbelt/Docker), cryptographic tool receipts; YOLO mode available |
| IronClaw | WASM sandbox for untrusted tools (capability-based permissions, endpoint allowlisting, credential injection at host boundary, leak detection); Docker sandbox for containers; AES-256-GCM secrets; no telemetry |
| NanoClaw | True OS-level container isolation (Linux containers, filesystem mounts); credential gateway injects auth at proxy level; no raw API keys in containers |
| NullClaw | Pairing, strict sandboxing (landlock, firejail, bubblewrap, docker), allowlists, workspace scoping, ChaCha20-Poly1305 encrypted secrets, resource limits, audit logging |
| MicroClaw | Tool risk gates, scoped grants, egress controls, Docker sandboxing, secret redaction, audit trails |
| PicoClaw | Security hardening (.security.yml, sensitive data filtering); isolation support; note: "may have unresolved security issues; do not deploy to production before v1.0" |
| NemoClaw | OpenShell sandbox around the wrapped agent; container security measures, capability drops, process limits, network policy, credential handling |
| TinyAGI | Sender pairing allowlist; per-agent isolated workspaces |
3.8 Hardware support
| Project | Target hardware |
|---|---|
| OpenClaw | General (any OS) |
| ZeroClaw | Raspberry Pi, STM32, Arduino, ESP32 via Peripheral trait (GPIO/I2C/SPI/USB) |
| IronClaw | General (macOS/Linux/Windows/WSL) |
| NanoClaw | macOS/Linux/WSL2 (Docker) |
| NullClaw | ARM, x86, RISC-V; $5 hardware; also Cloudflare Worker (edge MVP) |
| MicroClaw | macOS/Linux/Windows; native desktop (Apple Silicon macOS 13+) |
| PicoClaw | RISC-V, ARM, MIPS, x86; $10 boards; Android (APK) |
| NemoClaw | DGX / WSL hosts |
| TinyAGI | macOS/Linux/WSL2 |
3.9 Extensibility model
| Project | Extensibility |
|---|---|
| OpenClaw | Extensions folder; 53 config files (per NanoClaw's critique) |
| ZeroClaw | Crates (channels/providers/tools/hardware); MCP servers; skills |
| IronClaw | WASM tools/channels, MCP, dynamic tool building ("describe what you need") |
| NanoClaw | "Skills over features" — trunk is registry+infra; channels/providers added via /add-* skills into your fork; code changes over config |
| NullClaw | vtable interfaces (swap implementations via config, zero code changes); community skill packs (TOML/JSON/YAML SKILL.md) |
| MicroClaw | Skills, manifest plugins, hooks, MCP, ClawHub, A2A, ACP; embeddable SDK |
| PicoClaw | MCP, skills (ClawHub), Agent Plugins 1.0.0 (fork) |
| NemoClaw | Agent-specific aliases, blueprint lifecycle, skills |
| TinyAGI | Plugin system (message hooks, event listeners); custom providers |
3.10 Target deployment
| Project | Deployment shape |
|---|---|
| OpenClaw | Full-featured personal agent (Node) |
| ZeroClaw | Single binary, any OS/platform, always-on service |
| IronClaw | Agent OS with WebUI, background service, Docker |
| NanoClaw | Per-user fork, container-isolated, skills-based |
| NullClaw | Edge/$5 hardware, static binary |
| MicroClaw | Server (always-on) + native desktop (Work) + SDK |
| PicoClaw | Edge/IoT/Android, WebUI launcher |
| NemoClaw | Sandbox layer over an existing agent |
| TinyAGI | Multi-agent team orchestrator with web portal |
4. Distinctions that matter
4.1 NemoClaw is a sandbox wrapper, not a standalone agent
NemoClaw's own README: "Run agents like Hermes, LangChain Deep Agents, and OpenClaw more securely inside NVIDIA OpenShell." It is a TypeScript CLI + blueprint that provisions an OpenShell sandbox, routes inference, and applies network policy. It does not run an agent loop itself — the agent (OpenClaw/Hermes/DeepAgents) runs inside. Comparing NemoClaw's "stars" or "channels" to ZeroClaw's is comparing a sandbox product to an agent runtime. If you want an agent, NemoClaw is not it; if you want to secure an agent, it is.
4.2 PicoClaw: upstream vs. fork
- Upstream:
sipeed/picoclaw— 30.1k ⭐, 2,584 commits, Go, MIT, "independent open-source project initiated by Sipeed … written entirely in Go from scratch — not a fork of OpenClaw, NanoBot, or any other project." - Fork:
afjcjsbx/picoclaw— 47 ⭐, 3,275 commits, explicitly labeled "Actively maintained fork" with WebUI/MCP/plugins. It self-describes as a fork; upstream does not endorse it.
Both are MIT, so forking is permitted. But star counts, commit counts, and feature lists are not interchangeable between them. When quoting "PicoClaw has 30k stars," that's the upstream; the fork has 47.
4.3 NullClaw benchmarks are self-reported
The NullClaw README's "Benchmark Snapshot" table (RAM/startup/binary size vs. OpenClaw, NanoBot, PicoClaw, ZeroClaw) is NullClaw's own measurement on its own machine (/usr/bin/time -l on ReleaseSmall builds, Feb 2026, macOS arm64, normalized to 0.8 GHz edge) [project-reported]. It is not an independent benchmark, not reproducible by a third party from the README alone, and it compares NullClaw's best case (ReleaseSmall, static) against others' default distributions. Use it as a directional claim, not evidence.
4.4 NanoClaw's critique of OpenClaw is NanoClaw's own framing
NanoClaw's README says OpenClaw has "nearly half a million lines of code, 53 config files, and 70+ dependencies" with "application-level (allowlists, pairing codes) rather than true OS-level isolation" and "everything runs in one Node process with shared memory." These are NanoClaw's statements about OpenClaw [project-reported by NanoClaw], not independently measured. They're useful as a design-philosophy signal (NanoClaw's whole thesis is "small enough to understand"), but should not be quoted as audited facts.
4.5 OpenClaw is the common ancestor (conceptually)
IronClaw explicitly says it is "a Rust reimplementation inspired by OpenClaw." NanoClaw, PicoClaw, TinyAGI, and MicroClaw all cite OpenClaw as inspiration. NullClaw and ZeroClaw position themselves as independent but target the same niche. NemoClaw wraps OpenClaw. So OpenClaw remains the reference point for feature parity (IronClaw ships a FEATURE_PARITY.md).
5. Where ZeroClaw sits
Grounded facts from ZeroClaw's own README [as of 2026-11-04]:
- Language: Rust. Single binary. Dual-licensed MIT OR Apache-2.0.
- Scale: 33.1k ⭐, 5.0k forks, 5,803 commits, 716 issues, 442 PRs.
- Channels: 30+ (Discord, Telegram, Matrix, email, voice, webhooks, CLI, ACP, …).
- Providers: ~20 (Anthropic, OpenAI, Ollama, and others).
- Features: multi-channel agent loop, provider-agnostic with fallback chains/routing, security-first with supervised autonomy + OS sandboxes (Landlock/Bubblewrap/Seatbelt/Docker) + cryptographic tool receipts, hardware (GPIO/I2C/SPI/USB on Pi/STM32/Arduino/ESP32), HTTP/WS gateway + web dashboard, SOP engine (event-triggered procedures with approval gates and resumable runs), ACP (JSON-RPC 2.0 over stdio for IDE integration).
- Config: one TOML file (
~/.zeroclaw/config.toml), V3 shape with<type>.<alias>sections. - Install: Unix installer, Windows PowerShell path, Docker, NixOS, source build. (Install commands omitted here per scope; see the repo.)
- Official repo notice: ZeroClaw Labs declares
zeroclaw-labs/zeroclawthe only official repo; any other claiming affiliation is unauthorized.
What ZeroClaw does not publish: a binary size, RAM, or startup figure in its own README. The only such numbers come from NullClaw's self-reported comparison (§3.2), which should be labeled as such.
6. Methodology & sources
Method: primary sources only — each project's GitHub repo page and README. Every number in §2 and §3 is from the live repo page [as of 2026-11-04]. Secondary/quoted claims (NullClaw benchmark table, NanoClaw's OpenClaw critique, star-count drift) are tagged [project-reported].
Primary sources (all fetched 2026-11-04):
github.com/openclaw/openclaw(393.8k ⭐, 82.8k forks, 124,906 commits, MIT)github.com/zeroclaw-labs/zeroclaw(33.1k ⭐, 5.0k forks, 5,803 commits, MIT/Apache-2.0)github.com/nearai/ironclaw(12.7k ⭐, 1.5k forks, 4,073 commits, MIT/Apache-2.0)github.com/nanocoai/nanoclaw(31.1k ⭐, 12.7k forks, 3,054 commits, MIT)github.com/nullclaw/nullclaw(8.2k ⭐, 960 forks, 2,837 commits, MIT)github.com/nullclaw/nullhub(1.8k ⭐, 86 forks, 458 commits, MIT)github.com/microclaw/microclaw(751 ⭐, 139 forks, 1,268 commits, MIT)github.com/sipeed/picoclaw(30.1k ⭐, 4.4k forks, 2,584 commits, MIT)github.com/afjcjsbx/picoclaw(47 ⭐, 14 forks, 3,275 commits, MIT) — active forkgithub.com/NVIDIA/NemoClaw(22.9k ⭐, 3.2k forks, 6,351 commits, Apache-2.0)github.com/TinyAGI/tinyagi(3.6k ⭐, 505 forks, 198 commits, MIT)
Tagging convention used throughout:
[as of YYYY-MM-DD]— snapshot value from a live page fetch.[project-reported]— stated by the project itself, not independently verified.[verified]— checked against source code or primary documentation in this writeup.
Not covered here (out of scope / not found): HKUDS/nanobot (referenced by NullClaw/PicoClaw comparisons but not fetched), hermes-agent, deepagents. If you need those, they should be fetched and added with the same discipline.
Prepared 2026-11-04. Numbers drift; re-fetch before quoting. EOF echo done