There's something almost absurd about the standard advice for running an AI agent. "You'll need at least a 4GB VPS," the tutorials say. "Make sure you have enough RAM for the Node.js runtime." For a service that mostly sits idle waiting for messages, then forwards them to an API and returns the response, the resource requirements of most AI agent runtimes are wildly disproportionate to the actual work being done.
ZeroClaw breaks that pattern. It uses 4MB of RAM at idle. A Raspberry Pi Zero 2 W — a computer the size of a credit card that costs $15 — has 512MB of RAM. ZeroClaw uses less than 2% of it.
The Hardware You Need
The minimum viable setup costs about $33: a Raspberry Pi Zero 2 W ($15), a 32GB microSD card ($8), and a USB-C power supply ($10). That's a one-time cost with no monthly fees, no subscription, no cloud bill. For comparison, ChatGPT Plus costs $20/month. Your Pi pays for itself in under two months, and then runs for free indefinitely.
If you already have a Raspberry Pi 3, 4, or 5 sitting in a drawer, you don't need to buy anything. Any Pi from the last several years has more than enough resources to run ZeroClaw.
Why ZeroClaw Can Run on Hardware This Small
Most AI agent runtimes are built on top of Node.js or Python — runtimes that carry significant overhead even when idle. Node.js needs to initialize the V8 engine, load the module system, and resolve a dependency tree of hundreds or thousands of packages before it can process a single message. That's why OpenClaw needs 1.2GB of RAM just to sit there.
ZeroClaw is a native Rust binary. There's no runtime to initialize, no garbage collector running in the background, no dependency tree to load. The binary starts, reads its config file, opens its database connection, and is ready to process messages. The entire process uses about 4MB of RAM — roughly the same as a text file.
The actual AI processing happens on the provider's servers (Anthropic, OpenAI, etc.) or on a separate machine running Ollama. ZeroClaw's job is message routing, memory management, and tool execution — tasks that are computationally lightweight and well-suited to constrained hardware.
Setting It Up
1. Flash the OS
Download Raspberry Pi OS Lite (64-bit) from raspberrypi.com and flash it to your SD card using Raspberry Pi Imager. During setup, enable SSH and configure your WiFi credentials — this lets you manage the Pi headlessly without a monitor or keyboard.
2. Install ZeroClaw
SSH into your Pi and run the bootstrap script:
```bash curl -fsSL https://raw.githubusercontent.com/zeroclaw-labs/zeroclaw/main/scripts/bootstrap.sh | bash ```
The script detects ARM64 architecture and downloads the pre-built binary. No compilation needed — it takes about 30 seconds on a decent WiFi connection.
3. Configure Your Provider
Edit `~/.config/zeroclaw/config.toml`:
```toml [ai] provider = "anthropic" model = "claude-sonnet-4-20250514" api_key = "sk-ant-..."
[channels.telegram] token = "YOUR_BOT_TOKEN" allowed_users = [123456789] ```
You can use any cloud provider — OpenAI, Anthropic, Google, Groq — or point it at an Ollama instance running on another machine in your network. The Pi doesn't need to run the model itself; it just needs to route messages to wherever the model lives.
4. Run as a Service
Create a systemd service so ZeroClaw starts automatically on boot and restarts if it crashes:
```bash sudo tee /etc/systemd/system/zeroclaw.service << 'EOF' [Unit] Description=ZeroClaw AI Agent After=network-online.target Wants=network-online.target
[Service] Type=simple User=pi ExecStart=/home/pi/.cargo/bin/zeroclaw start Restart=always RestartSec=5
[Install] WantedBy=multi-user.target EOF
sudo systemctl enable --now zeroclaw ```
Your AI assistant is now running, will survive reboots, and draws about 0.4 watts of power — roughly $0.50 per year in electricity.
What It Actually Performs Like
Real measurements on a Raspberry Pi Zero 2 W: cold start around 50ms (slower than x86, but still imperceptible to users), memory usage of 4.2MB RSS, and message routing latency under 5ms from receiving a message to sending the API request. Power consumption sits at roughly 0.4W idle.
The bottleneck is always the AI provider's API response time — typically 1–3 seconds for a typical query. ZeroClaw's contribution to that latency is negligible. From the user's perspective, the Pi is invisible.
What You Can Actually Do With It
The use cases are broader than most people initially imagine. A family Telegram group bot for homework help and recipe suggestions. A home automation interface that connects to Home Assistant for natural language control of lights and thermostats. An IoT monitoring agent that parses sensor data and sends alerts when thresholds are exceeded. A personal journal that you talk to through Signal, with all conversation history stored locally on the Pi. A quick code question and documentation lookup assistant accessible from your phone.
The common thread is that all of these are "always on" use cases — services that need to be available 24/7, respond quickly, and run reliably without intervention. A Pi running ZeroClaw handles all of them simultaneously, on hardware that draws less power than a night light.
Going Further: Local Models on Pi 5
If you have a Raspberry Pi 5 with 8GB of RAM, you can run small language models locally with Ollama:
```bash ollama pull qwen3:1.5b ```
The 1.5B parameter model runs at roughly 2 tokens per second on Pi 5 — slow by cloud standards, but functional for simple queries, and completely offline. For a home assistant that handles basic questions without sending any data to the internet, it's a compelling option.
The Bigger Point
The Raspberry Pi isn't just a cheap way to run ZeroClaw. It's a demonstration of what's possible when your infrastructure software respects the hardware it runs on. A $33 computer running a 4MB binary, drawing half a watt of power, handling multiple chat channels simultaneously, available 24/7 — that's what "deploy anywhere" actually means in practice.