Building Jarvis at Home: OpenClaw on Raspberry Pi 5

2026/02/04

So, I had this idea. I wanted a personal AI executive assistant. But not just another chatbot that gives me recipes or generic life advice. I wanted something that could actually do stuff, read my emails, check if my stocks are crashing, and maybe keep an eye on my server stats so I don’t have to.

And, honestly, I wanted it running locally. Call me paranoid, but I like my data staying in my house (mostly). Plus, I didn’t want it eating up my electricity bill like a full-blown desktop would.

Enter the Raspberry Pi 5. It’s basically the perfect candidate: sips power, has decent performance, and fits in my pocket. But… SD cards are slow. Painfully slow for an AI agent that needs to think fast. That’s where the NVMe SSD and the official M.2 HAT came in.

In this post, I’ll walk you through how I turned this little board into a Jarvis using OpenClaw, repurposing my existing Antigravity (Jio) subscription to power it with Gemini models for… Well, free. Which is my favorite price.

Why Raspberry Pi 5 + NVMe?

Look, the standard SD card bottleneck is real. If you’ve ever waited for a dist-upgrade on an SD card, you know the pain. For an AI agent that needs to be always on and responsive, I wanted the reliability and speed of an SSD. I grabbed the Raspberry Pi M.2 HAT+ and slapped a standard 256GB NVMe drive on it. It’s honestly a game-changer. The Pi feels like a real computer now.

But the real reason? Isolation. I gave OpenClaw its own dedicated environment on the Pi. I didn’t want a powerful, semi-autonomous agent having unrestricted access to my personal laptop where I keep my banking details and embarrassing photos. The Pi is my AI Sandbox, a safe, contained playground where the agent can run wild. If it breaks something, it breaks the Pi, not my life.

My Hardware List:

Step 1: The OS & NVMe Boot Setup

First things first: getting the OS running on the NVMe. I flashed Raspberry Pi OS Lite (64-bit) using the Raspberry Pi Imager. I chose the Lite version because I don’t need a desktop environment eating up RAM, every megabyte counts for the AI.

To get the most out of the drive, I edited /boot/firmware/config.txt to enable PCIe Gen 3. It’s technically experimental but works flawlessly for me.

dtparam=pciex1
dtparam=nvme
dtparam=pciex1_gen=3

I also made sure the bootloader was updated to support NVMe booting:

sudo rpi-eeprom-config --edit
# Changed BOOT_ORDER to 0xf41 (NVMe first, then SD)

Step 2: Installing OpenClaw

OpenClaw is the engine behind the agent. It runs on Node.js. I installed Node.js v25 using nvm (Node Version Manager) to avoid those annoying permission issues where you have to sudo everything and then regret it later.

# Install nvm (standard stuff)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
source ~/.bashrc

# Grab Node v25
nvm install 25

Then, installing OpenClaw was just:

npm install -g openclaw

Simple enough.

Step 3: Repurposing My Subscription (The Magic Part)

Okay, here is the cool part. I basically discovered that I already have an Antigravity subscription bundled with my Jio plan. Instead of paying for a separate API key or dealing with copy-pasting massive config files, OpenClaw has this neat OAuth flow.

I honestly just ran:

openclaw onboard
  1. Selected Google Antigravity from the list.
  2. It popped open a link, I logged in with my Google account which has the Antigravity access.
  3. Done. No API keys to copy, no secrets to manage. It just worked.

After that, I wanted to make sure it wasn’t burning through expensive tokens, so I set the ‘fallback’ model to the lighter Gemini options:

openclaw models options

Here is exactly how I configured the openclaw.json (redacted, obviously) to use the Gemini 2.5 Flash Lite model via this Antigravity session. It’s fast, smart enough for agent tasks, and best of all, cost-effective.

{
  "auth": {
    "profiles": {
      "google-antigravity:user@example.com": {
        "provider": "google-antigravity",
        "mode": "oauth",
        "email": "user@example.com"
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "openrouter/moonshotai/kimi-k2-thinking",
        "models": {
            "google/gemini-2.5-flash-lite": {}
        }
      }
    }
  }
}

To configure this interactively, I just ran:

openclaw onboard

…and selected “Google Antigravity from the list.

Step 4: Access Anywhere with Tailscale

I wanted to control Jarvis from anywhere, coffee shop, office, or bed. I set up Tailscale and used their serve feature to put the OpenClaw dashboard on a nice internal HTTPS URL.

sudo tailscale serve reset --yes && sudo tailscale serve --bg --https 18789 18789

Now I can visit https://pi-xxxxx.tail5XX106.ts.net:18789/ from my phone (as long as I’m on my Tailnet) and see what the agent is doing.

Security Note: The first time you visit from a new device, OpenClaw blocks it. I had to SSH in and run:

openclaw devices list
openclaw devices approve <DEVICE_ID>

Smart move for a dashboard exposed to the web.

Step 5: Telegram Integration

Finally, the interface. I didn’t want to build a custom React app just to talk to it. Telegram is perfect for this. I created a bot via @BotFather, got the token, and added it to my config.

Now, I chat with my Pi like this:

2. On-the-Fly Skill Creation

This is where OpenClaw actually kind of blew my mind. I don’t need to code a new plugin for everything.

3. The Limitless (but Realistic) Potential of MCP

The real power here isn’t just what comes out of the box. OpenClaw supports MCP (Model Context Protocol), which basically means you can plug it into anything. Want it to talk to your Notion? Want it to manage your Linear tickets or query a Postgres database? Done.

The capabilities are technically limitless, but let’s keep it grounded: you don’t need to build Skynet on day one. Start small. I use it for stocks and emails. Maybe next week I’ll hook it up to my Home Assistant. The point is, the option to expand is there when you’re ready to tinker.

Future Roadmap: Scaling with my MacBook

The Pi 5 is great for the always-on gateway, but sometimes I need more raw horsepower. OpenClaw supports clustering. My next step to mess around with is onboarding my MacBook Air as a remote worker node.

The plan:

  1. Run openclaw onboard on the Mac.
  2. Connect it to the Pi’s gateway.
  3. Offload heavy tasks (like local image generation or complex coding) to the Mac when it’s online, while the Pi handles the 24/7 light duties.

Conclusion

I’m really happy with how this turned out. It turns the Raspberry Pi 5 into a genuinely useful assistant rather than just another board collecting dust in my drawer. The combination of NVMe speed + OpenClaw’s agentic stuff + the free Gemini access via Jio makes it a killer weekend project.