A ZeroClaw Raspberry Pi setup runs the agent software on your board and connects it to a model provider. This guide covers Raspberry Pi Zero 2 W and Raspberry Pi 4 with 64-bit Raspberry Pi OS. The original Pi Zero and Zero W have a different processor architecture and cannot use this guide's aarch64 download.
Verification note: hardware specifications, release assets, and commands were checked against official sources on October 14, 2026, using ZeroClaw v0.8.5. This is source-checked guidance, not a fresh Raspberry Pi installation test or performance benchmark. The retained Imager screenshots come from the original February walkthrough; captions identify what they actually show.
Which Raspberry Pi can run ZeroClaw?#
| Board | Processor architecture | What to use |
|---|---|---|
| Original Raspberry Pi Zero / Zero W | ARMv6, 32-bit ARM11; 512 MB RAM | Not the aarch64 instructions below. A separate 32-bit OS and matching ARM build are required. |
| Raspberry Pi Zero 2 W | ARMv8-A, quad-core Cortex-A53; 512 MB RAM | 64-bit OS and aarch64 Linux binary; keep the workload small and use a remote model. |
| Raspberry Pi 4 Model B | ARMv8-A, quad-core Cortex-A72; several RAM capacities | 64-bit OS and aarch64 Linux binary; more headroom for the runtime and other services. |
The distinction comes from Raspberry Pi's architecture table, Zero model specifications, and Pi 4 specifications.
The v0.8.5 release assets include arm-unknown-linux-gnueabihf and armv7-unknown-linux-gnueabihf builds as well as aarch64 GNU and musl builds. The installer maps ARMv6 to the generic ARM target. That is not evidence of a successful original-Zero hardware test; treat it as a separate compatibility investigation. ARMv7 binaries are not a substitute for ARMv6 binaries.
Agent runtime versus running a model locally#
ZeroClaw is an agent runtime: it manages conversations, tools, and provider requests. A hosted API does the model inference elsewhere. A local model server such as Ollama adds its own model weights, memory, and compute requirements.
This walkthrough uses a hosted provider. A Zero 2 W's 512 MB must also support Linux; do not interpret a small agent footprint as enough memory for a useful local language model. On a Pi 4, local inference depends on the board's RAM, model, quantization, and context size and needs separate measurement. There is no universal memory or response-speed guarantee here, and release builds should not all be described as static or dependency-free.
Step 1: Prepare 64-bit Raspberry Pi OS#
You need the board, suitable power supply, microSD card, card reader, another computer, and a network connection. In Raspberry Pi Imager, select your actual board and Raspberry Pi OS Lite (64-bit) for this headless setup. Lite avoids a desktop you will not use over SSH. Writing the card erases its existing contents, so check the selected storage device.

Original February screenshot: this shows the desktop 64-bit edition, not Lite. For the headless instructions above, choose the Lite 64-bit edition in your current Imager. Menu layout may differ.
Set a hostname such as claw, choose a username, and configure Wi-Fi if needed. Pi 4 has built-in Ethernet; a wired connection on Zero 2 W needs a compatible USB Ethernet adapter and USB OTG adapter. Wi-Fi is also a valid setup path. Complete the SSH settings in Step 2 before writing the card.
Step 2: Enable SSH and check the architecture#
In Imager, enable SSH with public-key authentication and supply your public key. Keep the private key on your own computer. If you need a new key, run this on that computer and follow its prompts without overwriting an existing key:
ssh-keygen -t ed25519

Original February screenshot: SSH is enabled and public-key authentication is selected. The number of keys shown belongs to that earlier setup.
Write the card, insert it, connect the network, and power on. From your computer, connect using the username and hostname you chose; this example assumes zero and claw:
ssh zero@claw.local
If name resolution fails, use the Pi's address from your router in place of claw.local. See Raspberry Pi's SSH and remote-access documentation.
Run these commands inside the Pi's SSH session:
uname -m
dpkg --print-architecture
getconf LONG_BIT
free -h
For the download below, expect aarch64, arm64, and 64 respectively. Check all three: a 64-bit CPU or kernel alone does not prove that the installed userspace is 64-bit. If you see armv6l, armv7l, armhf, or 32, stop before downloading the aarch64 build. On Zero 2 W or Pi 4, install the intended 64-bit OS first.
Step 3: Install the pinned ZeroClaw binary#
The commands below use the GNU aarch64 build for 64-bit Raspberry Pi OS, pinned to v0.8.5. They install the CLI into your user's ~/.local/bin; they do not install the optional browser dashboard assets or compile Rust on the Pi. Asset names and archive layout were checked against the release and tagged installer.
First install the download tools:
sudo apt update
sudo apt install -y ca-certificates curl tar
Then paste this block into the Pi's shell. The subshell stops if a download or checksum check fails:
(
set -eu
workdir=$(mktemp -d)
cd "$workdir"
version=v0.8.5
asset=zeroclaw-aarch64-unknown-linux-gnu.tar.gz
base="https://github.com/zeroclaw-labs/zeroclaw/releases/download/$version"
curl -fL "$base/$asset" -o "$asset"
curl -fL "$base/SHA256SUMS" -o SHA256SUMS
awk -v file="$asset" '$2 == file || $2 == "*" file {print}' SHA256SUMS > selected.sha256
test -s selected.sha256
sha256sum -c selected.sha256
tar -xzf "$asset"
mkdir -p "$HOME/.local/bin"
install -m 755 zeroclaw "$HOME/.local/bin/zeroclaw"
"$HOME/.local/bin/zeroclaw" --version
)
Continue only after checksum verification succeeds and the version command runs. A checksum confirms agreement with the release manifest; the release page also documents stronger attestation verification. Keep using the full binary path below so shell PATH differences do not interrupt setup.

Reference screenshot of the official release assets. This confirms the download name, not a successful Pi installation.
Step 4: Configure a provider and test one request#
Start the v0.8.5 Quickstart flow:
"$HOME/.local/bin/zeroclaw" quickstart

Reference screenshot of the tagged documentation; this is not terminal output from a Pi.
Follow the official setup checklist: select your hosted provider, enter its credentials at the prompt, and choose a model your account can access. Configure a risk profile, choose a memory backend such as SQLite, and create an agent with the alias assistant. Keep approvals enabled while you test. Optional channels and peer groups can wait; CLI chat is enough for the first check. Do not include credentials in screenshots.
Send one small request, substituting your actual alias if you chose a different one:
"$HOME/.local/bin/zeroclaw" agent -a assistant -m "Reply with one short greeting."
A returned model response is the end-to-end check: the Pi can start the runtime and reach the configured provider. A printed version number alone does not prove that. Provider usage may incur charges. This update did not perform a live provider request on a Pi, so no success screenshot is claimed.
Once that request works, you can optionally register and start the background service:
"$HOME/.local/bin/zeroclaw" service install
"$HOME/.local/bin/zeroclaw" service start
Troubleshooting and practical limits#
| Symptom | Next check |
|---|---|
Exec format error | Repeat the architecture checks. Do not run an x86, ARMv7, or 64-bit binary on a mismatched OS. |
Loader or GLIBC error | Check OS version and the selected GNU/musl release target. Do not fix this by copying arbitrary system libraries. |
| Process is killed or the Pi becomes unresponsive | Inspect free -h and system logs for memory pressure; reduce concurrent services and optional features. |
| Provider authentication or model error | Check credentials, account access, model selection, and connectivity before changing hardware. |
| Version check works but no model reply | Installation succeeded only as far as starting the binary; troubleshoot the provider request separately. |
Start with one agent and one hosted model. Measure your actual workload before adding browser automation, multiple channels, or local inference. A prebuilt binary avoids the additional resources required for a source build. Raspberry Pi Connect and Tailscale are optional remote-access choices, not prerequisites for this local-network walkthrough.
