What Is ZeroClaw? A Plain-English Introduction
Start here. What the runtime actually does, who it is for, and how the pieces fit together — no prior knowledge assumed.
ZeroClaw: The Ultra-Lightweight Rust AI Agent Runtime
ZeroClaw is an open-source runtime for autonomous AI agents, written in Rust. It runs in under 5MB of RAM, starts in milliseconds, and ships as a single binary that works on everything from a server to a $10 ARM board.
What is ZeroClaw?
ZeroClaw is a runtime framework for agentic workflows. That phrase does a lot of work, so here is the concrete version: an AI agent needs four things to be useful — a model to think with, somewhere to remember what happened, tools it can act through, and a channel a human can reach it on. ZeroClaw provides all four behind swappable interfaces, so you describe your agent once and change the model, the storage backend or the messaging app underneath it without rewriting anything.
What separates it from comparable projects is what it costs to keep running. Most agent runtimes are built on Node.js or Python, which means a language runtime sitting in memory consuming hundreds of megabytes before your agent has done a single thing. ZeroClaw is compiled Rust with no garbage collector and no interpreter, so an idle agent occupies a few megabytes and starts in single-digit milliseconds.
That difference is not academic. It is the difference between needing a Mac mini and needing a Raspberry Pi Zero — between one agent per machine and twenty. If you want the longer version, read our full introduction to ZeroClaw.
What makes it different
Small enough to forget about
A resident footprint under 5MB and a 3.4MB binary. You can run a dozen agents on hardware that would struggle to start one Node-based runtime, and you stop having to think about whether a machine can afford to host one.
Cheap to operate
The runtime will happily live on a $10 ARM board. Pair it with a local model through Ollama and the marginal cost of running an agent drops to the electricity it draws — no per-token billing, no subscription.
Fast to start
Cold start is measured in milliseconds rather than seconds, even on slow cores. That makes it practical to start an agent on demand instead of keeping a daemon warm purely to avoid a painful boot.
Genuinely portable
One self-contained binary covers ARM, x86 and RISC-V. There is no interpreter to install, no dependency tree to resolve and no version manager to fight — you copy a file to the machine and run it.
How it compares
The table below is a quick local benchmark run on macOS arm64 in February 2026, normalised for 0.8GHz edge hardware. Treat it as an order-of-magnitude guide rather than a precise measurement — your numbers will vary with build flags and hardware.
| Metric | OpenClaw | NanoBot | PicoClaw | ZeroClaw |
|---|---|---|---|---|
| Language | TypeScript | Python | Go | Rust |
| Resident memory | > 1GB | > 100MB | < 10MB | < 5MB |
| Startup (0.8GHz core) | > 500s | > 30s | < 1s | < 10ms |
| Binary size | ~28MB distribution | Scripts, no binary | ~8MB | 3.4MB |
| Runtime dependency | Node.js (~390MB) | Python interpreter | None | None |
| Viable hardware | Mac mini, ~$599 | Linux SBC, ~$50 | Linux board, ~$10 | Any board, ~$10 |
Detailed head-to-head breakdowns: OpenClaw vs ZeroClaw, ZeroClaw vs PicoClaw, and the three-way 2026 comparison.
How the architecture works
ZeroClaw is built around traits — Rust’s version of interfaces. Every subsystem is defined by a contract rather than a concrete implementation, which is what makes the parts interchangeable. The memory provider, the model provider, the messaging channel and the tool executor are all pluggable, and swapping one is a configuration change rather than a code change.
Provider <---> [ Runtime Adapter ] <---> Channel
^
Memory <---> [ Security Policy ] <---> Tools
v
Observer <---> [ Identity Config ] <---> TunnelThe practical consequence is that you can develop against a cheap local model and move to a frontier hosted model in production by editing one line of config.toml, with no change to the agent itself.
The security model in brief
An autonomous agent that can read files and run commands is a genuine risk, and ZeroClaw treats it as one. Four controls do most of the work:
- Workspace scoping. File operations are confined to one directory. An agent asked to read your SSH keys simply cannot see them.
- Command allowlists. Shell execution is deny-by-default. Only the executables you name —
git,cargo, whatever the job needs — can be invoked. - Pairing. A new channel connection must present a pairing code, so finding your bot is not the same as being able to command it.
- Encrypted secrets. Provider API keys are encrypted at rest against a local key file rather than sitting in plaintext config.
Defaults are sensible but not sufficient on their own. Our guide to the ZeroClaw security model covers what each control does and does not protect against, and how to tighten them.
Skills and plugins
Two separate extension mechanisms are easy to confuse. Skills are instructional: a folder containing a SKILL.md file whose frontmatter declares a name, description, version, category and the permissions it needs, followed by instructions the agent reads when the skill is triggered. They change what the agent knows how to do.
Plugins are executable: WebAssembly components compiled for wasm32-wasip2, which run sandboxed and deny-by-default, receiving only the capabilities their manifest.toml declares. They change what the agent can actually do. Both install from the command line, and both are covered in our skills and plugins guide.
Guides on this site
How to Install ZeroClaw on Windows, Ubuntu, macOS and Docker
Every supported installation route, the differences between them, and how to verify the install actually worked.
ZeroClaw Security: Workspace Scoping, Allowlists and Sandboxing
The four controls that stand between an autonomous agent and your filesystem, and how to configure each one properly.
The ZeroClaw config.toml Reference
Every section of the configuration file explained, with complete working examples for local and hosted models.
ZeroClaw Skills and Plugins Explained
How SKILL.md files extend an agent's behaviour, how WASM plugins differ, and how the permission model governs both.
ZeroClaw Web UI, Gateway and Tunnel Setup
Running the web dashboard, exposing the gateway safely, and what the pairing code protects you from.
Set Up a ZeroClaw Bot with Ollama and Telegram
A fully local agent you can message from your phone, with no API key and no cloud dependency.
Running ZeroClaw on a Raspberry Pi Zero
What actually happens when you put a Rust agent runtime on the cheapest board Raspberry Pi sells.
Frequently asked questions
What is ZeroClaw?
ZeroClaw is an open-source runtime for AI agents, written in Rust. It provides the plumbing an agent needs — a model provider, memory, tools, and a messaging channel — behind swappable interfaces, so an agent can be defined once and run anywhere. Its defining characteristic is size: the runtime targets a memory footprint under 5MB and ships as a single static binary.
Is ZeroClaw the same thing as OpenClaw?
No. They solve a similar problem but are separate projects with different implementations. OpenClaw is written in TypeScript and runs on Node.js; ZeroClaw is written in Rust and compiles to a standalone binary with no runtime dependency. ZeroClaw ships a migration path that can import an existing OpenClaw setup.
What platforms does ZeroClaw support?
ZeroClaw builds for macOS (Apple Silicon and Intel), Linux and Windows, and because it is a static binary it also targets ARM, x86 and RISC-V boards. Android is possible through Termux. See our installation guide for the exact steps on each platform.
Do I need an OpenAI API key to use ZeroClaw?
No. ZeroClaw talks to any OpenAI-compatible endpoint, so you can point it at OpenRouter, OpenAI, Anthropic, or a fully local server such as Ollama. Running a local model means no API key and no per-token cost at all.
What are the hardware requirements?
The runtime itself is the cheap part — a few megabytes of RAM and storage, which a Raspberry Pi Zero or a $10 ARM board can supply. The real requirement comes from the model. A hosted API needs almost nothing locally; running a local model through Ollama needs enough RAM to hold that model, typically 4GB or more.
How does ZeroClaw keep an agent from doing damage?
Through four layers: workspace scoping restricts file access to a single directory, a command allowlist means only explicitly permitted executables can run, new channel connections require a pairing code, and API keys are encrypted at rest. Our security guide walks through how to configure each one.
Is ZeroClaw free?
The runtime is open-source and free to run. Your only cost is whatever your model provider charges — which is zero if you run models locally — plus the hardware you run it on.