I have been running OpenClaw (an open-source agent framework that orchestrates large language models against local tools and APIs) on a handful of single-board computers (SBCs) for the last six months. The honest summary is that the Raspberry Pi 5 is the easy path, but it is not the only path. The community has built ports and slimmed-down builds that run on the Orange Pi 5, the Rock 5B, the Pinebook Pro, the Khadas VIM4, and a couple of smaller RK3566 boards that I would not have expected to keep up. If you already own an SBC that is not a Raspberry Pi, you can almost certainly get OpenClaw on it. The work is mostly in the build configuration, not the hardware.
This is the part of the open-source story I want to write down. The Raspberry Pi is the default, the docs assume it, and most blog posts online show a Pi 5 with the official 27-watt power supply. That framing leaves out a lot of perfectly capable hardware. Hardware like the Orange Pi 5 with 4GB of RAM, the Rock 5B with 8GB, and the reComputer Industrial R2145 with 16GB. These boards are real, they ship in volume, and they are sitting in drawers because the standard tutorials skip over them.
Why the Pi is the default, and where it falls short
OpenClaw runs as a long-lived process, talks to one or more model endpoints, and orchestrates tool calls. On a fresh install, it wants about 1.2 GB of RAM for the base runtime and grows depending on which tools you wire in. The Pi 5 with 8 GB handles this comfortably. The Pi 4 with 4 GB is tight but workable if you disable the browser side of the stack and stick to headless (server-only, no graphical desktop) operation. The Pi 3 and earlier do not have enough RAM to run a 7B-parameter model (a large language model with 7 billion internal weights, the smallest size that is still useful for general agent work) and the agent loop at the same time.
The Pi 5 also has the best out-of-box experience for OpenClaw because the project’s official images include a pre-built container. That container is compiled for the Pi’s ARMv8.2 instruction set with hardware float (a CPU feature that speeds up the math large language models rely on) enabled. The official images do not work on most other ARM boards without recompilation. That is the gap. Not hardware, software.
What I tested and how it ran
I spent the last six months running OpenClaw on five boards that are not the Pi 5. Here is what I found, in concrete terms.
- Orange Pi 5 (4 GB). Runs OpenClaw 0.9.x after a manual compile with the rockchip-specific tensor overlays (pre-compiled kernel modules that accelerate matrix math on Rockchip’s NPU, a neural processing unit built into the CPU). Cold-start time is about 8 seconds. The 4 GB limit is real. You can run a 7B model with the context window (the amount of text the model can consider at once) trimmed to 2048 tokens and the agent loop will hold, but a 13B model will swap (a state where the operating system moves data from fast RAM to slower disk because RAM is full) under load.
- Rock 5B (8 GB). Best non-Pi experience I have had. The Radxa build chain has first-class OpenClaw support, and the 8 GB lets you run 13B models comfortably. Power draw at idle is 6 watts. Under agent load, 11 watts. The Pi 5 is 4 watts idle and 9 watts under load, so the Rock 5B is not a huge penalty.
- Khadas VIM4 (8 GB). Worked, but the community build is two releases behind upstream. You have to pin (lock to a specific version) OpenClaw to a tag that the VIM4 build supports, which means you miss new features.
- Pinebook Pro (4 GB). Old, slow, but it works. The eMMC (embedded MultiMediaCard, a soldered-on storage chip) is the bottleneck. Cold-start takes 22 seconds. The agent loop is fine once it warms up. I would not recommend it for daily use, but for an offline workshop demo it is a fine talking piece.
- reComputer Industrial R2145 (16 GB). Overkill for most use cases, but it is the only board I have tested that runs a 70B model (a very large language model that needs 40+ GB of RAM to run, so this works only with offloading some layers to disk) with disk offloading. Not the cheapest path. Useful if you want one box that does everything.
The community discord has build instructions for each of these. Most are scripts that clone the OpenClaw repo, apply a board-specific patch, and rebuild the container. The whole loop takes 15-30 minutes on a board with 4 GB of RAM, faster on the 8 GB boards.
The actual install (Orange Pi 5 walkthrough)
The Orange Pi 5 is the closest thing to a Raspberry Pi drop-in replacement. Here is the build sequence I use, starting from a fresh Armbian (a Debian-based Linux distribution built for ARM single-board computers) install.
sudo apt update
sudo apt install -y build-essential git docker.io
sudo usermod -aG docker $USER
# Log out and back in for the group change to take effect
git clone https://git.example.com/openclaw/openclaw.git
cd openclaw
git checkout v0.9.4
docker build -t openclaw:local --build-arg BOARD=orangepi-5 .
docker run -d --name openclaw -p 8080:8080 \
-v /opt/openclaw-data:/data \
openclaw:local
The build takes about 12 minutes on the Orange Pi 5 and produces a container that runs the agent loop, the model broker, and the web UI. The web UI is on port 8080. The first request after start-up will take 3-4 seconds as the model loads into memory. Subsequent requests are under 200ms for a 7B model.
The two flags worth knowing about are --build-arg BOARD=orangepi-5 (or rock-5b, vim4, etc.) and the data volume at /opt/openclaw-data. The volume holds your config, your agent history, and any cached model files. Back it up before you rebuild the container. I have lost an afternoon’s worth of agent history to a careless docker rm more than once.
Trade-offs
None of these boards are a perfect Raspberry Pi replacement. Here is what you give up.
- Pi camera and GPIO (General-Purpose Input/Output, the physical pins on a Raspberry Pi that let it control LEDs, buttons, and sensors) tooling. OpenClaw on a Pi 5 can use the camera module and the GPIO pins directly. The Orange Pi and Rock 5B have their own equivalents, but they need extra configuration. If you are building a hardware-tinkerer agent setup, the Pi 5 still wins.
- Community size. When something breaks on a Pi 5, you can search Discord and find a thread in under five minutes. When something breaks on the Rock 5B, you might be the second person to hit the issue. The Orange Pi 5 community is bigger than the Rock 5B community, which is bigger than the VIM4 community.
- Power efficiency. The Pi 5 is hard to beat on watts-per-operation. If you are running this 24/7 in a closet, that 2-3 watt difference matters over a year.
- Long-term support. The Pi foundation is not going anywhere. Smaller SBC vendors have come and gone. Buy the hardware with that in mind.
If you already own one of these boards, the trade-offs are mostly time. If you are buying new hardware specifically for OpenClaw, the Pi 5 is the sensible default. The other boards are for when you already have the hardware on a shelf and want to put it to work.
What I would tell past me
- The official Pi image is a starting point, not a ceiling. If you are comfortable with Docker, the build for an Orange Pi or Rock 5B is one afternoon. The docs make it look harder than it is.
- 8 GB of RAM is the practical floor for 2026. 4 GB works for a headless 7B setup. It does not work for anything more ambitious.
- Pin your OpenClaw version to whatever your SBC community supports. A bleeding-edge OpenClaw on an out-of-tree SBC build is a recipe for a Sunday spent debugging linker errors.