If you have arrived here after searching "what is ZeroClaw", you have probably already read the one-line answer: an ultra-lightweight AI agent runtime written in Rust. That sentence is accurate and almost useless. This guide is the longer answer.
The problem ZeroClaw exists to solve
Building an AI agent that does something genuinely useful involves far more code than most people expect, and almost none of it is the interesting part.
Say you want an agent that watches a folder for new invoices, extracts the totals, and messages you a summary on Telegram. The actual intelligence — reading an invoice and pulling out a number — is a single model call. Everything around it is plumbing:
- Something has to talk to the model provider, handle rate limits, and retry on failure.
- Something has to remember what the agent already processed, so it does not message you twice about the same invoice.
- Something has to expose the filesystem to the agent without exposing your entire home directory.
- Something has to receive your Telegram messages, route them to the agent, and send replies back.
- Something has to keep all of this running, restart it when it dies, and log what happened.
Write that yourself and you have spent a week on infrastructure to deploy an hour of actual agent logic. Worse, all of it is tightly coupled: swapping OpenAI for a local model, or Telegram for Discord, means rewriting the parts that touch them.
An agent runtime is the framework that owns this plumbing. ZeroClaw is one.
What ZeroClaw actually provides
ZeroClaw defines each piece of that plumbing as an interface — a trait, in Rust terminology — and ships implementations you select through configuration.
Providers are the connection to a model. ZeroClaw speaks the OpenAI-compatible API shape, which by now is the industry's lingua franca, so a provider can be OpenAI itself, OpenRouter, Anthropic, or a local server such as Ollama or llama.cpp. Changing provider is a config edit.
Memory is what the agent knows across sessions. ZeroClaw includes its own memory engine with no external dependency — no Pinecone, no Elasticsearch, no separate vector database to operate. It stores to SQLite or plain Markdown files, and retrieves with a hybrid of vector similarity and keyword matching so that relevant context is recalled automatically rather than being manually stuffed into every prompt.
Channels are how humans reach the agent. Telegram, WhatsApp, a web dashboard, or the terminal. The agent logic does not know or care which one delivered a message.
Tools are what the agent can do beyond generating text: read a file, run a command, make an HTTP request. This is where the security model matters, because a tool is by definition a way for a language model to affect the real world.
Identity is the agent's persona and behavioural definition. ZeroClaw supports the AI Entity Object Specification (AIEOS), a portable JSON format describing traits, motivations and linguistic style, and it also reads OpenClaw's Markdown identity files directly.
Why "lightweight" is the headline feature
Every agent runtime provides roughly the components above. What distinguishes ZeroClaw is what it costs to keep one running.
Most agent frameworks are written in TypeScript or Python. Both are excellent languages with enormous ecosystems, and both require a language runtime resident in memory for the entire life of your program. A Node.js process is consuming hundreds of megabytes before your agent has processed a single message. The Node.js distribution alone is around 390MB on disk.
ZeroClaw is compiled Rust. There is no interpreter, no garbage collector and no runtime to load — the binary contains everything, and the operating system runs it directly. The consequences are concrete:
| | Node-based runtime | ZeroClaw | |---|---|---| | Resident memory, idle | Over 1GB | Under 5MB | | Distribution size | ~28MB plus a ~390MB runtime | 3.4MB, self-contained | | Cold start on a slow core | Minutes | Under 10 milliseconds | | Dependency install | npm tree, lockfile, version manager | Copy one file |
The memory figure is the one that changes what is possible. Under 5MB means a Raspberry Pi Zero is a viable host. It means twenty agents on a machine that could not comfortably run one Node process. It means the cost of leaving an agent running indefinitely is close to nothing, which in turn means you stop rationing them.
The startup figure changes architecture. When cold start is measured in milliseconds, you can start an agent on demand and let it exit when done, instead of keeping a daemon warm purely to avoid a painful boot.
Who ZeroClaw is for
It is a strong fit if you are:
- Running on constrained hardware. Single-board computers, routers, industrial gateways, an old laptop in a cupboard. This is the case ZeroClaw was designed for.
- Running many agents. The per-agent overhead is what limits density, and ZeroClaw's is unusually small.
- Deploying to mixed architectures. One binary covers ARM, x86 and RISC-V without a per-platform toolchain.
- Working offline or air-gapped. Pair it with Ollama and the entire stack runs locally with no outbound network access.
- Security-sensitive. Deny-by-default tool execution and workspace scoping are built in rather than bolted on.
It is a weaker fit if you are:
- Prototyping quickly in Python. If your workflow is a notebook and a pile of Python libraries, a Python-native framework will have less friction, and the memory savings will not matter on your laptop.
- Dependent on a large plugin ecosystem. ZeroClaw is younger than the JavaScript and Python alternatives, and the catalogue of ready-made integrations is correspondingly smaller.
- Uncomfortable compiling from source. Prebuilt binaries and package-manager installs exist, but you are closer to the build tooling here than with an npm install.
How ZeroClaw relates to OpenClaw
This is the most common follow-up question, and the naming does not help.
OpenClaw is an established agent runtime written in TypeScript, running on Node.js, with a mature ecosystem. ZeroClaw is a separate project addressing the same problem in Rust, with resource efficiency as its organising principle. They are not forks of one another and not maintained by the same people.
The relationship is deliberate compatibility. ZeroClaw reads OpenClaw's Markdown identity files, and ships a migration command that imports an existing OpenClaw configuration and memory store. The intent is that moving from one to the other does not mean starting over.
Whether the move is worth making depends entirely on whether resource consumption is a problem you actually have. If OpenClaw runs comfortably on your hardware and your integrations work, efficiency is an abstract virtue. If you are trying to fit an agent onto a board with 512MB of RAM, it is the whole ballgame. Our OpenClaw vs ZeroClaw comparison works through the trade-off in detail.
What using it looks like
The rough shape of getting started:
- Install the binary — via a package manager, a prebuilt release, or by building from source. Our installation guide covers each route per platform.
- Run onboarding, which writes a starter configuration and stores your provider credentials encrypted.
- Edit
config.tomlto select your model, memory backend and channels. The configuration reference explains each section. - Set your security boundaries — the workspace directory and the command allowlist. Do this before, not after, giving the agent anything interesting to do. See the security guide.
- Talk to it, from the terminal, the web dashboard, or a messaging channel you have connected.
A realistic first project is a local agent reachable from your phone: ZeroClaw with Ollama and Telegram walks through one end to end, with no API key and no cloud dependency.
The honest caveats
A few things worth knowing before you commit:
It is young. Interfaces are still moving. Expect to read release notes before upgrading, and expect some configuration keys to change between versions.
The runtime is small; the model is not. A footprint under 5MB describes ZeroClaw itself. If you run a model locally through Ollama, that model needs its own memory — typically several gigabytes. A Raspberry Pi Zero can host the runtime, but it cannot host a 7B parameter model. Point it at a hosted API and the local requirement really does stay tiny.
Benchmarks are directional. Published comparisons, including ours, are quick local measurements on specific hardware with specific build flags. The order of magnitude is trustworthy; the exact numbers are not a guarantee.
Verify the source. There are multiple repositories and domains using the ZeroClaw name. Install from the official project repository and check what you are downloading. This site is an independent guide, not the project itself.
Where to go next
If you want to install it, start with the installation guide. If you want to understand the configuration before committing, read the config.toml reference. If you are evaluating it against alternatives, the three-way comparison is the most complete write-up on this site.
And if you are going to let an agent run commands on a machine you care about, read the security guide first. That one is not optional.