How to Deploy OpenClaw Agents on Raspberry Pi Compute Module 4

Raspberry Pi guarantees the Compute Module 4 will remain in production until at least January 2034. That commitment matters when you are designing industrial systems that need a decade of supply chain stability. The CM5 is faster, but its carrier board ecosystem is still maturing. The CM4 has years of proven reliability data, established certifications, and a deep bench of purpose-built carrier boards from companies like Waveshare, Seeed, and BLIIoT.

OpenClaw officially supports Raspberry Pi 4 hardware. The CM4 uses the identical BCM2711 quad-core Cortex-A72 SoC, which means the same ARM64 binaries run without modification. The difference is form factor: instead of a standalone single-board computer, the CM4 plugs into a carrier board designed for your specific deployment environment. That carrier board might expose industrial protocols, DIN rail mounting, PoE, or cellular connectivity that a bare Pi 4 cannot offer.

For always-on OpenClaw agents that need to survive power cycles, temperature extremes, or vibration, the CM4's onboard eMMC storage eliminates the SD card failure mode that kills long-running Pi deployments. The 8GB RAM variant with 32GB eMMC costs roughly $75 to $80 at MSRP, well under the $90 to $120 range for a comparable CM5 configuration.

The practical question is not whether the CM4 can run OpenClaw. It can. The question is which carrier board and deployment configuration match your environment, and when the CM5 migration path becomes worth the premium.

The CM5 is objectively more powerful, but raw performance is rarely the bottleneck for an OpenClaw agent. The agent acts as an orchestration layer, managing tool calls, channel integrations, and workflow automation while delegating inference to cloud APIs. That means the SoC spends most of its time waiting on network I/O, not crunching tensors.

Here is how the two modules compare for this specific workload:

The CM5 delivers a 4.74x single-core performance improvement according to Geekbench benchmarks. That gap matters if you plan to run local model inference, compile extensions, or handle concurrent agent sessions. For a single always-on agent making API calls and managing file operations, the CM4's 1.5GHz quad-core handles the load without breaking a sweat.

The CM5 is a drop-in upgrade for most CM4 carrier boards since it uses the same connector. So deploying on CM4 today does not lock you out of upgrading later. You get the mature ecosystem now and a clear migration path when supply and pricing stabilize.

The carrier board determines what your CM4 can actually connect to in the physical world. For an OpenClaw agent running headless at the edge, you need reliable power input, Ethernet or cellular connectivity, and enough I/O for your monitoring or automation requirements.

Industrial gateways like the BLIIoT BL460 series demonstrate what a purpose-built edge platform looks like. These boards combine a compute module with industrial protocol support (Modbus, OPC-UA, MQTT), DIN rail mounting, wide temperature tolerance from -20C to 85C, and integrated I/O for sensors and actuators. BLIIoT has published case studies showing their gateway integrated with OpenClaw for IIoT, smart manufacturing, and smart city applications.

General-purpose boards like the official Raspberry Pi IO Board or Waveshare CM4-NANO provide a development platform without industrial hardening. These work well for prototyping or controlled-environment deployments where temperature and vibration are not concerns.

Network-focused boards like the Seeed Dual Gigabit Carrier route the PCIe lane through a USB 3.0 controller to provide dual Gigabit Ethernet plus USB 3.0. This suits network-attached agent deployments where the CM4 sits between segmented networks.

Key selection criteria for OpenClaw deployments:

• Storage interface: Boards with M.2 or NVMe support reduce SQLite I/O bottlenecks. OpenClaw's frequent small writes degrade SD card lifespans quickly.
• Power input: Look for wide-range DC input (9-36V) or PoE for deployments where USB-C power is impractical.
• Thermal management: Passive heatsinks or fanless enclosures suit environments where fan maintenance is impossible.
• Watchdog timer: Hardware watchdog support ensures the agent restarts after unexpected hangs without human intervention.

Stop losing edge agent output to local disk failures

Give your CM4 OpenClaw agents a durable workspace that humans can query from anywhere. generous storage, no credit card, MCP-ready endpoint for reads and writes.

Start 14-Day Trial

The CM4 installation follows the same path as a standard Raspberry Pi 4, with one difference: you flash the OS to onboard eMMC rather than an SD card. This requires the official IO Board or any carrier board with a USB boot jumper and a USB-C slave port.

Flash the OS:

Use Raspberry Pi Imager to write Raspberry Pi OS Lite (64-bit) to the CM4's eMMC. Set hostname, enable SSH, and configure WiFi during the imaging step. The Lite image skips the desktop environment, which saves RAM and reduces attack surface for a headless deployment.

System preparation:

After first boot, SSH into the device and update the base system. OpenClaw needs Node.js, git, and basic build tools. For CM4 boards with only 4GB RAM, adding a 2GB swap file prevents out-of-memory conditions during installation. The 8GB variant handles installation without swap, but adding 1GB of swap as a safety margin costs nothing.

Install OpenClaw:

The official install script handles dependencies and sets up the daemon. When the onboarding wizard asks about daemon installation, accept it. This creates a systemd user service that starts OpenClaw automatically on boot.

For reliable unattended operation, enable lingering so the user service survives SSH disconnection:

sudo loginctl enable-linger $(whoami)

Verify the service:

Check the agent is running and healthy after a reboot:

systemctl --user status openclaw-gateway.service
journalctl --user -u openclaw-gateway.service --no-pager -n 50

Access the OpenClaw control UI through an SSH tunnel on port 18789, or configure a reverse proxy if the carrier board's network setup allows it.

Channel configuration:

On headless installs, OAuth-based channels can be tricky since there is no local browser. Telegram integration works cleanly on ARM64 without browser-based authentication. Configure your API keys and preferred LLM provider (Anthropic, OpenAI, or Google) through the onboarding wizard or by editing the configuration files directly.

An always-on edge agent generates data: logs, processed documents, sensor readings, reports. Storing everything on the CM4's 32GB eMMC creates a ticking time bomb. You need a durable, searchable, and shareable storage layer that the agent can write to without filling local disk.

Local options like mounting an NFS share or syncing to S3 work but require ongoing infrastructure management. The CM4's PCIe Gen 2 x1 lane limits local NVMe to about 400MB/s, which is fine for agent workloads but overkill for what amounts to document and log uploads.

Fastio provides workspace storage designed for exactly this pattern. The agent writes files to a Fastio workspace via the MCP server or API, where they are automatically indexed for semantic search through Intelligence Mode. A human operator can query those files from the web UI without SSH access to the edge device.

The workflow for an industrial deployment looks like this:

1. OpenClaw agent on the CM4 collects data, runs analysis, or processes documents
2. Agent uploads results to a Fastio workspace via Streamable HTTP at /mcp
3. Intelligence Mode indexes the uploads for RAG-based queries
4. Human operators search, download, or ask questions about the data from any browser
5. When the engagement ends, ownership transfers from the agent to a human account

The Business Trial includes 50GB storage, included credits, and 5 workspaces with no credit card required. For a single edge agent producing documents and reports, that ceiling is rarely the constraint.

File locks prevent conflicts if you run multiple agents writing to the same workspace. Webhooks notify downstream systems when new files arrive. These features turn Fastio from passive storage into an active coordination layer between edge agents and the humans who consume their output.

Compared to Dropbox or Google Drive, the difference is that Fastio workspaces are intelligence-native. Upload a document and it is already indexed, searchable by meaning, and queryable through the AI chat interface. There is no separate vector database to configure or RAG pipeline to maintain.

Running OpenClaw on a CM4 in a lab is straightforward. Keeping it running for months without intervention in an industrial environment requires deliberate hardening.

Watchdog configuration:

Enable the hardware watchdog so the kernel reboots automatically if the system hangs:

sudo apt install watchdog

Configure /etc/watchdog.conf to monitor system load, available memory, and the OpenClaw process. If the agent stops responding, the watchdog triggers a clean reboot rather than leaving the device in a zombie state.

Filesystem protection:

Mount the root filesystem as read-only where possible. OpenClaw needs write access to its data directory and SQLite database, so mount those on a separate writable partition. This protects the base OS from corruption during unexpected power loss, which is common in industrial environments without UPS protection.

Thermal throttling:

The BCM2711 throttles at 80C. In enclosed industrial housings without active cooling, sustained workloads can push temperatures above this threshold. Monitor with vcgencmd measure_temp and ensure your carrier board's thermal solution handles your ambient temperature range. Most industrial carrier boards include passive heatsinks rated for their published operating range.

Network resilience:

Edge agents lose connectivity. Configure OpenClaw to queue outbound operations when the network is unavailable and flush when connectivity returns. For Fastio uploads, the agent can write to a local spool directory and batch-upload when the connection stabilizes. Webhooks handle the inverse: missed webhook deliveries retry automatically.

Update strategy:

Automated unattended-upgrades for security patches keep the OS current. For OpenClaw itself, pin to a specific version and test updates on a staging device before rolling to production. The CM4's eMMC supports A/B partition schemes if your carrier board's bootloader configuration allows it, enabling atomic rollbacks on failed updates.

Monitoring:

Without a screen, you need remote observability. Send systemd journal logs to a central syslog server or use the agent itself to report health status through its configured channels. A daily heartbeat message through Telegram or a webhook POST to your monitoring stack confirms the device is alive and the agent is responsive.