If you want a personal AI assistant that lives on your own hardware, OpenClaw on a Raspberry Pi is a compelling setup. It can connect to messaging platforms like WhatsApp, Telegram, Discord, and WebChat, use a local workspace for memory and instructions, and run as an always-on assistant from a small, low-power machine.

In this guide, I’ll walk through a practical Raspberry Pi setup for OpenClaw, explain the key configuration decisions, and point out a few gotchas that are easy to miss on a first install.

Why use a Raspberry Pi for OpenClaw?

A Raspberry Pi is a good fit if you want OpenClaw running continuously without dedicating a full desktop or laptop to the job.

A Pi-based setup gives you:

• an always-on box for your gateway and assistant
• lower power usage than a desktop machine
• a dedicated place for your OpenClaw workspace and memory files
• a clean separation between your personal devices and your assistant runtime

That said, the Pi works best when you keep the setup practical. If you want the most stable messaging setup, use Node as your runtime and start conservative with permissions and automations.

What you need

Before you begin, make sure you have:

• a Raspberry Pi with a current Linux install
• network access and SSH, if you prefer headless setup
• Node.js available on the Pi
• npm installed
• an OpenClaw-compatible model provider configured during onboarding
• optionally, a dedicated messaging account or number for your assistant

If you plan to use WhatsApp, OpenClaw’s docs strongly lean toward using a dedicated number rather than your personal one. That keeps boundaries cleaner and reduces accidental self-chat weirdness.

Step 1: Install OpenClaw

On the Raspberry Pi, install OpenClaw globally with npm:

npm install -g openclaw@latest

If you already have Node and npm set up properly, this is usually the quickest path. OpenClaw’s local docs also note that Node is the recommended runtime, especially for WhatsApp and Telegram. Bun is not recommended for a stable messaging gateway.

After installation, confirm the CLI is available:

openclaw --help

If that works, you’re ready to onboard.

Step 2: Run the onboarding flow

Start the setup wizard:

openclaw onboard

The onboarding flow will guide you through:

• choosing and authenticating a model provider
• selecting a workspace directory
• configuring the gateway
• optionally setting up channels like WhatsApp, Telegram, or Discord
• running a health check

For most Raspberry Pi installs, the default workspace path is fine:

~/.openclaw/workspace

That workspace becomes the assistant’s home. It stores the instructions, memory files, and operating context that shape how your OpenClaw assistant behaves.

Step 3: Understand the workspace

One of the most important parts of OpenClaw is the workspace. By default, OpenClaw seeds files like:

• AGENTS.md
• SOUL.md
• TOOLS.md
• IDENTITY.md
• USER.md
• HEARTBEAT.md

These files define how the assistant should behave, what it should remember, and how it should interact with you.

The docs recommend treating this workspace like real memory. That means backing it up and, ideally, putting it in git so your changes are tracked.

If git is installed, a new workspace may even be auto-initialized for you.

Step 4: Start conservative with configuration

When OpenClaw is first running on a Pi, it’s smart to avoid overexposing it.

A minimal WhatsApp-focused configuration from the docs looks like this:

{
  channels: {
    whatsapp: {
      allowFrom: ["+15555550123"]
    }
  }
}

That single setting already makes the system much safer than leaving access wide open. The docs explicitly recommend setting channels.whatsapp.allowFrom and not running a personal assistant open to the world.

If you want more of a general assistant setup, a fuller configuration might include:

• your chosen model
• the workspace path
• a heartbeat setting
• group mention rules
• session reset behavior

For example:

{
  logging: { level: "info" },
  agent: {
    model: "anthropic/claude-opus-4-6",
    workspace: "~/.openclaw/workspace",
    thinkingDefault: "high",
    timeoutSeconds: 1800,
    heartbeat: { every: "0m" }
  },
  channels: {
    whatsapp: {
      allowFrom: ["+15555550123"],
      groups: {
        "*": { requireMention: true }
      }
    }
  },
  routing: {
    groupChat: {
      mentionPatterns: ["@openclaw", "openclaw"]
    }
  },
  session: {
    scope: "per-sender",
    resetTriggers: ["/new", "/reset"],
    reset: {
      mode: "daily",
      atHour: 4,
      idleMinutes: 10080
    }
  }
}

Even if you don’t use this exact config, the broader lesson is useful: begin with tight access controls, then loosen things only when you trust the setup.

Step 5: Be careful with heartbeats

OpenClaw supports heartbeats, which let the assistant proactively check in or perform routine tasks.

That can be powerful, but it can also burn tokens fast if enabled too early. The docs recommend starting with heartbeats disabled until you trust the setup:

{
  agent: {
    heartbeat: { every: "0m" }
  }
}

Once the system feels stable, you can enable a schedule such as every 30 minutes and keep the HEARTBEAT.md file tightly scoped so it doesn’t wander.

Step 6: Link your preferred channels

OpenClaw supports several messaging surfaces, including:

• WhatsApp
• Telegram
• Discord
• WebChat
• Signal
• Google Chat
• iMessage options through supported integrations

For WhatsApp, the normal link flow is:

openclaw channels login --channel whatsapp

For Telegram and Discord, setup is token-based rather than phone-link-based.

If you’re running on a Raspberry Pi in a headless environment, plan your channel setup before you begin. Some channels are easier than others depending on whether you have access to the device needed for login or approval steps.

Step 7: Start the gateway

Once onboarding and channel setup are done, start the gateway:

openclaw gateway

In many cases, you’ll want the gateway to run persistently so the assistant stays available even after you disconnect from SSH.

OpenClaw’s docs describe daemon installation options during onboarding. On Linux systems, that usually means a systemd user unit so the gateway can keep running more reliably.

Step 8: Check status and health

After the gateway is up, verify that everything is healthy:

openclaw status
openclaw status --all
openclaw status --deep
openclaw health --json

These commands are useful for slightly different reasons:

• openclaw status gives a quick local view
• openclaw status --all gives a fuller diagnosis
• openclaw status --deep adds gateway health probes
• openclaw health --json gives a structured health snapshot

If something feels off, these should be among the first commands you run.

Step 9: Personalize the assistant

Once the system is stable, spend time on the workspace files rather than chasing endless config tweaks.

The real personality and usefulness of OpenClaw usually come from:

• refining SOUL.md
• documenting preferences in USER.md
• keeping practical environment notes in TOOLS.md
• writing down meaningful continuity in memory files

This is where the assistant becomes yours instead of just being a generic install.

Common Raspberry Pi gotchas

A few issues show up often in small-device deployments:

1. Choosing the wrong runtime

If you experiment with Bun because it sounds faster, expect instability. OpenClaw’s docs are pretty direct that Node is the recommended runtime, and Bun is not recommended for WhatsApp and Telegram-heavy setups.

2. Opening access too far

A personal assistant on a Pi can become surprisingly capable. If you expose it loosely, you may end up with a system that can message back, edit files, and run commands for the wrong people. Start with allowlists.

3. Turning on proactive behavior too early

Heartbeats and automations are great once you trust the assistant. Before that, they can create noise, consume tokens, or do the wrong thing on a schedule.

4. Treating the workspace as disposable

Your workspace is the assistant’s memory. Back it up. Put it in git. Review it occasionally. If the Pi dies and you didn’t preserve the workspace, you lose much of what made the assistant useful.

A simple first goal for your Pi setup

If you’re just starting out, don’t try to wire up every channel and automation on day one.

A good first milestone is:

1. install OpenClaw

2. complete onboarding

3. create a minimal workspace

4. connect one messaging surface

5. verify status and health

6. have one reliable conversation with the assistant

Once that works, add memory habits, safer automation, and richer routing.

Final thoughts

Running OpenClaw on a Raspberry Pi is one of the nicest ways to give a personal assistant a permanent home. It’s lightweight, practical, and surprisingly capable when paired with a well-maintained workspace and conservative configuration.

The key is not to overcomplicate the first install. Use Node, keep access locked down, treat the workspace seriously, and add proactive features only after the basics are solid.

That way, your Raspberry Pi doesn’t just host software. It hosts an assistant that can actually grow with you.