Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/openagen/zeroclaw/llms.txt

Use this file to discover all available pages before exploring further.

ZeroClaw is a single-binary Rust runtime that runs on any hardware you can deploy a process to: servers, SBCs, Android phones, and microcontrollers connected via USB. The same agent loop that runs on a Mac mini runs on a $10 Linux board, keeping startup under 10ms and RAM under 5MB on release builds.

​
Supported platforms

ZeroClaw targets all major CPU architectures with a single binary-first workflow:
ArchitectureExample hardwareNotes
aarch64 (ARM64)Raspberry Pi 4, Apple M-series, modern AndroidPrimary embedded target
x86_64Linux servers, Intel NUCsDefault CI target
riscv64gcSiFive, StarFive boardsSupported via cross-compilation
armv7Raspberry Pi 2, older Android phones32-bit ARM; API 16+ on Android
The benchmark below is normalized for a 0.8 GHz edge core (macOS arm64, Feb 2026 measurements on release builds):
OpenClawNanoBotPicoClawZeroClaw
LanguageTypeScriptPythonGoRust
RAM> 1 GB> 100 MB< 10 MB< 5 MB
Startup (0.8 GHz)> 500 s> 30 s< 1 s< 10 ms
CostMac Mini $599Linux SBC ~$50Linux board $10Any hardware $10
RAM figures are runtime memory for release builds. Build-time compilation requirements are higher. OpenClaw includes ~390 MB of Node.js runtime overhead not shown in the table.

​
Peripheral trait system

Hardware boards are modelled as Peripheral implementations in src/peripherals/traits.rs. Each peripheral connects, exposes a list of Tool implementations (such as gpio_read, gpio_write, adc_read), and disconnects cleanly on shutdown. 
#[async_trait]
pub trait Peripheral: Send + Sync {
    fn name(&self) -> &str;
    fn board_type(&self) -> &str;  // e.g. "nucleo-f401re", "rpi-gpio"
    async fn connect(&mut self) -> anyhow::Result<()>;
    async fn disconnect(&mut self) -> anyhow::Result<()>;
    async fn health_check(&self) -> bool;
    /// Tools this peripheral provides (gpio_read, gpio_write, sensor_read, etc.)
    fn tools(&self) -> Vec<Box<dyn Tool>>;
}
At startup ZeroClaw reads [peripherals] from config.toml, constructs a Peripheral for each configured board, calls connect(), and merges the resulting tools into the agent’s tool surface. The agent can then call gpio_write or sensor_read in response to natural language just as it calls any other tool.

​
Supported peripherals

BoardTransportTools exposed
nucleo-f401re (STM32)Serial / USB CDCgpio_read, gpio_write, adc_read
rpi-gpio (Raspberry Pi)Native (rppal / sysfs)gpio_read, gpio_write
esp32Serial or WebSocketgpio_read, gpio_write, wifi, mqtt
USB device discovery uses nusb for VID/PID enumeration. Serial communication uses tokio-serial with a newline-delimited JSON protocol. Raspberry Pi GPIO uses rppal.
nusb (USB discovery) is excluded on target_os = "android". Use host-mediated mode from a Linux or macOS host when working with Android targets.

​
Hardware CLI commands

​
Discovery and introspection

# Enumerate all connected USB devices (VID/PID, architecture, name)
zeroclaw hardware discover

# Inspect a specific device: memory map, peripheral list
zeroclaw hardware introspect /dev/ttyACM0

# Read board info (chip name, architecture, memory map)
zeroclaw hardware info

​
Peripheral management

# List configured and detected peripherals
zeroclaw peripheral list

# Flash firmware to a Nucleo-F401RE via probe-rs
zeroclaw peripheral flash-nucleo

# Manage peripheral connections
zeroclaw peripheral manage

​
Agent with peripheral

# Attach a peripheral at runtime
zeroclaw agent --peripheral nucleo-f401re:/dev/ttyACM0

# Use a J-Link probe
zeroclaw agent --probe jlink

# Edge-native mode (ZeroClaw runs on the device itself)
zeroclaw agent --mode edge

​
Feature flags

The hardware subsystem is gated behind feature flags to keep the default binary lean: 
# Enable all hardware and peripheral support
cargo build --release --features hardware

# Enable hardware + probe-rs for memory read and flash
cargo build --release --features hardware,probe

# Enable hardware + Raspberry Pi native GPIO (rppal)
cargo build --release --features hardware,peripheral-rpi

​
Configuration

Add boards to ~/.zeroclaw/config.toml so the agent knows which hardware to connect: 
[peripherals]
enabled = true
mode = "host"           # "edge" | "host"
datasheet_dir = "docs/datasheets"  # RAG: board-specific docs for LLM context

[[peripherals.boards]]
board = "nucleo-f401re"
transport = "serial"
path = "/dev/ttyACM0"
baud = 115200

[[peripherals.boards]]
board = "rpi-gpio"
transport = "native"

[[peripherals.boards]]
board = "esp32"
transport = "serial"
path = "/dev/ttyUSB0"
baud = 115200
Set datasheet_dir to a folder of .md or .txt files named by board (e.g. nucleo-f401re.md, rpi-gpio.md). ZeroClaw’s RAG pipeline retrieves relevant snippets on hardware queries and injects them into the LLM context.

​
Dive deeper

Running ZeroClaw on Android

Install and run ZeroClaw on Android via Termux, including architecture selection and ADB deployment.

STM32, Raspberry Pi, and USB peripherals

Flash firmware to a Nucleo-F401RE, configure RPi GPIO, and use probe-rs for memory introspection.

Build docs developers (and LLMs) love

Get started for freeTalk to us