How to Build a Personal AI Agent Desktop with Raspberry Pi 5 and OpenClaw

Raspberry Pi 5 board prices jumped 12% on the 8GB model in late 2025, pushed by LPDDR4 memory costs from datacenter AI buildouts. The 8GB board now sits at $90, up from $80 at launch. A complete desktop build with case, power supply, SSD, monitor, keyboard, and mouse lands around $200 to $250 depending on what you already own.

That sounds like real money until you compare it to recurring costs. A mid-tier cloud VM with comparable RAM runs $15 to $40 per month. Within six months, the Pi pays for itself. And unlike a cloud instance, the Pi sits on your desk, boots in under 30 seconds, and runs on about 5 watts at idle.

The Raspberry Pi blog announced official OpenClaw support in early 2026, calling out the Pi 5 with 8GB as the recommended configuration. OpenClaw's minimum requirements are modest (1GB RAM, 1 CPU core, 500MB disk), so the 8GB board leaves headroom for background tasks, sensor polling, and local caching. The Pi 5's quad-core Cortex-A76 CPU delivers roughly 2x the single-threaded performance of the Pi 4, and NVMe storage via the M.2 HAT+ pushes read speeds 5 to 10x beyond SD cards.

The pitch is straightforward: build once, run indefinitely. An always-on desktop AI agent that manages files, automates workflows, searches documents, and responds to natural language, all from hardware you physically control.

Every component here is available from authorized Pi resellers like CanaKit, PiShop, and The Pi Hut. Prices reflect May 2026 retail.

The board:

• Raspberry Pi 5 8GB ($90). The 4GB model works but leaves thin margins once OpenClaw, Node.js, and a browser are running simultaneously. The 16GB model at $145 is overkill for this build unless you plan to run additional services.

Power and cooling:

• Official 27W USB-C power supply ($12 to $15). Third-party supplies often trigger undervoltage warnings that cause throttling. The Pi 5 draws up to 12W under sustained load, and peripherals need the remaining headroom.
• Official Raspberry Pi case with integrated fan ($10). Without active cooling, the Pi 5 hits 85 degrees Celsius in about 90 seconds and throttles from 2.4GHz down to 1.8GHz. The stock fan case holds temperatures below 80 degrees at sustained load.

Storage:

• M.2 HAT+ and 256GB NVMe SSD ($40 to $60). SD cards work for initial setup but wear out under the constant small writes that OpenClaw generates. An NVMe drive is 5 to 10x faster on sequential reads and dramatically more durable. If budget is tight, a USB 3.0 SSD ($25 to $35) is a solid middle ground.
• 32GB microSD card ($8 to $12). Still needed for the initial OS flash, even if you boot from NVMe afterward.

Desktop peripherals:

• Any HDMI monitor. The Pi 5 outputs dual 4K60 via micro-HDMI. A micro-HDMI to HDMI cable runs $5 to $8.
• USB keyboard and mouse ($15 to $25 for a combo). The official Raspberry Pi keyboard includes a built-in USB hub, which is convenient for cable management.

Optional but recommended:

• Ethernet cable. Wired connections eliminate the Wi-Fi dropouts that can interrupt long-running agent tasks. Wi-Fi power management on the Pi occasionally drops connections mid-session.
• UPS HAT or small USB battery pack. Protects against filesystem corruption during power outages, especially important for the SQLite databases that OpenClaw uses for state.

Total build cost: $180 to $250 depending on monitor and storage choices. If you already have a display, keyboard, and mouse, the core build (board, PSU, case, SSD) runs about $155.

Assembly takes about 15 minutes. The official case snaps together without tools, and the M.2 HAT+ connects to the Pi 5's PCIe connector with a single ribbon cable and four standoffs.

Physical assembly:

1. Seat the Pi 5 board in the bottom half of the case
2. Connect the M.2 HAT+ ribbon cable to the PCIe FFC connector on the Pi 5
3. Mount the NVMe SSD into the M.2 slot on the HAT+
4. Attach the fan cable to the Pi 5's fan header
5. Close the case and connect peripherals: HDMI, keyboard, mouse, Ethernet

OS installation:

Download Raspberry Pi Imager on any computer. Flash Raspberry Pi OS (64-bit) to the microSD card. The 64-bit version is required, as OpenClaw does not support 32-bit. During the Imager setup, configure your hostname, enable SSH, set your username and password, and optionally configure Wi-Fi.

Insert the SD card, connect power, and the Pi boots to the desktop. Run a system update first:

sudo apt update && sudo apt upgrade -y

Move the boot to NVMe (recommended):

Once the OS is running from SD, use the SD Card Copier tool (under Accessories in the start menu) to clone the running OS to your NVMe drive. Then update the boot order in raspi-config to prioritize NVMe. Reboot, verify you're running from the SSD, and remove the SD card.

Optimize for always-on use:

Reduce GPU memory to 16MB if you plan to run headless most of the time (edit /boot/firmware/config.txt and set gpu_mem=16). Disable Bluetooth and other unused services to free resources:

sudo systemctl disable bluetooth
sudo systemctl disable cups

Create a 2GB swap file. This gives OpenClaw breathing room during memory-intensive operations like document parsing:

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Set swappiness to 10 (sudo sysctl vm.swappiness=10) to minimize unnecessary SSD writes while still having swap available when needed.

Give your Pi agent persistent storage and shareable workspaces

50GB free, no credit card. Connect OpenClaw to Fast.io's MCP server and your agent's output becomes searchable, shareable, and ready for handoff.

Sign Up Free

OpenClaw requires Node.js 24.x on Raspberry Pi OS. Install it from the NodeSource repository, then run OpenClaw's installer:

curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt install -y nodejs

Verify Node is installed (node --version should return v24.x), then install OpenClaw:

curl -fsSL https://openclaw.ai/install.sh | bash

The installer handles dependencies and walks you through an onboarding wizard where you configure your LLM provider. OpenClaw supports Anthropic Claude, OpenAI GPT, Google Gemini, and local models through Ollama or llama.cpp. For a Pi 5 desktop build, cloud APIs are the practical choice. Local LLM inference on the Pi is technically possible but too slow for conversational use. The Pi handles orchestration and tool execution while the LLM runs remotely.

After installation, test with a simple task. The Raspberry Pi blog demonstrated OpenClaw building a complete wedding photo booth application through plain English prompts, including webpage creation, Wi-Fi hotspot configuration, and admin access setup. Start smaller:

openclaw "List all PDF files in my Documents folder and summarize what each one contains"

OpenClaw reads the filesystem, sends file contents to your configured LLM, and returns structured results. The agent can chain actions: read files, make decisions based on content, create new files, send API requests, and manage system services.

Enable daemon mode for always-on operation:

Run OpenClaw as a systemd user service so it starts automatically on boot and persists after you close SSH sessions. Enable user lingering so systemd keeps your services running even when you're not logged in:

loginctl enable-linger $USER

Performance tuning:

Set the Node.js compile cache environment variable to speed up repeated module loads:

export NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache

Add this to your .bashrc or systemd service file. On constrained hardware, also set OPENCLAW_NO_RESPAWN=1 to reduce process handoffs.

OpenClaw stores its state in ~/.openclaw/ and working files in ~/.openclaw/workspace/. That works for single-user experimentation, but falls apart when you want to share agent output with teammates, back up results off-device, or hand off a completed project to someone else.

Local storage options for a Pi desktop include the NVMe SSD (fast, local, no network dependency) and USB external drives. Both work but create an island. Files live on one device, accessible only when you SSH in or sit at the desk.

Network-attached storage like a NAS or Syncthing instance solves the backup problem but not the sharing problem. You still need to manually send files to collaborators.

Cloud storage services like Google Drive or Dropbox sync files but lack the agent-native features that make the workflow smooth: API access for automated uploads, semantic search across stored documents, and structured handoff from agent to human.

Fast.io bridges this gap with workspaces designed for agent workflows. The free plan includes 50GB storage, 5,000 credits per month, and 5 workspaces, with no credit card required. Connect OpenClaw to Fast.io through the MCP server (Streamable HTTP at /mcp or legacy SSE at /sse), and your agent can upload files, organize them into workspaces, search across documents using built-in RAG, and create branded shares for external delivery.

The practical workflow looks like this: OpenClaw runs a task on your Pi (research, document generation, data extraction), uploads results to a Fast.io workspace, and the workspace's Intelligence layer auto-indexes everything for semantic search. You or a teammate open the workspace from any browser, ask questions about the files, and share results through a branded portal. The agent built it; a human reviews and distributes it.

Ownership transfer makes this particularly clean for client work. An agent account creates a workspace, populates it, then transfers the entire organization to a human account. The agent retains admin access for future updates, while the human takes over billing and external sharing.

For documents that need structured data extraction, Metadata Views let you describe fields in natural language and the AI extracts them into a sortable spreadsheet. An agent collecting invoices, contracts, or research papers on your Pi can push them to Fast.io where Metadata Views pull out dates, amounts, names, and categories automatically.

A dedicated AI desktop earns its keep through automation that runs while you do other things. Here are workflows that work well on a Pi 5 with OpenClaw.

Document triage and filing:

Point OpenClaw at a folder where you dump incoming files (scanned mail, downloaded PDFs, email attachments). The agent reads each document, classifies it (invoice, contract, receipt, personal letter), renames it with a descriptive filename, and moves it to the appropriate subfolder. Upload the organized results to a Fast.io workspace where Intelligence Mode makes everything searchable by content, not just filename.

Research aggregation:

Give the agent a research question and a list of sources. It fetches content, extracts relevant sections, compiles a summary document with citations, and stores the output. On a Pi running 24/7, you can schedule this as a daily job: "Check these 10 RSS feeds, summarize anything relevant to [topic], and upload the digest to my research workspace."

Smart home coordination:

The Pi 5's GPIO pins and USB ports connect to sensors, relays, and microcontrollers. OpenClaw can monitor a temperature sensor, decide whether to trigger a fan relay based on time of day and recent readings, and log decisions to a workspace for later review. The agent doesn't just follow threshold rules. It considers context and can explain its reasoning when you ask.

Meeting prep automation:

Before a recurring meeting, the agent gathers relevant files from your workspace, checks for updates since the last meeting, generates a summary of changes, and packages everything into a shareable link. Teammates get a branded Fast.io share with the latest materials, organized and searchable.

Offline-capable operation:

OpenClaw supports local model hosting through Ollama, llama.cpp, or LocalAI. While local inference on the Pi is slower than cloud APIs, it works without internet access. For privacy-sensitive tasks or locations with unreliable connectivity, you can run a small model locally for basic operations and switch to cloud APIs when bandwidth is available.

Each of these workflows benefits from persistent, shareable storage. The Pi handles orchestration and execution. A workspace like Fast.io handles the storage, search, sharing, and handoff layers that turn raw agent output into something a team can use.