OpenClaw Nodes: Turn Your Pi, Mac, and GPU Rig Into One Agent Network

The Tweet That Started This

A tweet from this morning captures exactly what we're diving into today:

> *"TIL: you can add nodes to your OpenClaw setup! This means that while I run most of OpenClaw on a Raspberry Pi, it can use the kids' iMac for iOS development, and my Windows gaming rig with an RTX3080 for some heavy lifting. Might have to put the Pi on ethernet, though!"*

If you've only been running OpenClaw on one machine, you've been leaving serious capability on the table. The Nodes system lets you pair multiple devices — and your main agent can reach out to them to run workloads, take screenshots, use cameras, and execute commands as if it owned those machines.

This post covers exactly how to set it up: Pi as the brain, Mac for iOS/design tasks, GPU rig for heavy compute.

---

What Are OpenClaw Nodes?

Nodes are secondary devices paired to your main OpenClaw Gateway. Your gateway runs on the primary machine (the "brain") and orchestrates everything. Nodes are paired devices that your agent can reach out to for:

The key insight: your agent's tools aren't limited to the machine it runs on. You get a distributed toolkit across your whole home network.

---

The Architecture: Three Machines, One Agent

Here's the setup we'll build:

| Machine | Role | Why |

|---|---|---|

| Raspberry Pi 5 | Brain / Gateway | Always-on, low power (~5W), boots fast |

| Mac (iMac/MacBook) | UI tasks, iOS dev, design | macOS-only tools, screenshots |

| Windows + RTX 3080 | Heavy compute, local LLMs, image gen | GPU workloads, Ollama, Stable Diffusion |

The Pi runs the OpenClaw gateway 24/7. The Mac and Windows rig are paired as nodes — they can be sleeping and only wake when your agent needs them (or you can keep them on).

---

Step 1: Set Up the Gateway on the Pi

Start with a fresh Raspberry Pi 5 (4GB RAM minimum, 8GB recommended). Install OpenClaw:

```bash

# On the Pi

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -

sudo apt-get install -y nodejs

npm install -g openclaw

# Start the gateway

openclaw gateway start

```

For the Pi to run 24/7 reliably, set it up as a systemd service:

```bash

sudo nano /etc/systemd/system/openclaw.service

```

Paste:

```ini

[Unit]

Description=OpenClaw Gateway

After=network.target

[Service]

Type=simple

User=pi

ExecStart=/usr/bin/openclaw gateway start

Restart=always

RestartSec=10

[Install]

WantedBy=multi-user.target

```

Then:

```bash

sudo systemctl daemon-reload

sudo systemctl enable openclaw

sudo systemctl start openclaw

```

Ethernet tip: The tweet author is right — put your Pi on ethernet. Wi-Fi on a Pi can introduce latency when your agent is trying to stream tool results from a node. Ethernet makes node communication snappy.

---

Step 2: Install the Node App on Your Mac

On the Mac, install the OpenClaw Node app. The Node app is a lightweight companion that:

```bash

# On the Mac

npm install -g openclaw

# Start as a node (not a full gateway)

openclaw node start --gateway http://<pi-ip>:PORT

```

The first time you run this, the Pi's OpenClaw dashboard will show a pending pairing request. Approve it:

```bash

# On the Pi, or via your agent

openclaw nodes list # See pending pairings

openclaw nodes approve <node-id>

```

Once approved, your Mac appears in your agent's `nodes` tool. You can verify from the Pi:

```bash

openclaw nodes list

# → mac-studio: online | last seen: just now

```

---

Step 3: Pair Your Windows GPU Rig

Same process on Windows. Install Node.js (v22+), then:

```bash

npm install -g openclaw

openclaw node start --gateway http://<pi-ip>:PORT

```

Approve the pairing from your agent. Now the GPU rig is available as a node named something like `windows-rig`.

---

Step 4: Using Nodes in Practice

Here's where it gets fun. Your agent — running on the Pi — can now reach out to either node for tasks.

Taking a screenshot of the Mac

```

"Hey Sam, take a screenshot of what's on my Mac screen right now"

```

Your agent calls:

```json

{

"action": "screen_record",

"node": "mac-studio",

"durationMs": 1000

}

```

It snapshots the Mac's display and describes what it sees. Useful for: "Check if my build finished on the Mac."

Running a command on the Windows rig

```

"Start the Ollama Llama 3.3 70B model on my gaming rig"

```

Your agent calls:

```json

{

"action": "run",

"node": "windows-rig",

"command": ["ollama", "run", "llama3.3:70b"]

}

```

This fires up the model on the GPU rig's RTX 3080 remotely. Your Pi agent can then make requests to Ollama running on the Windows machine's IP — full GPU power, no cloud.

Checking camera on the Pi itself

If your Pi has a camera module (or USB webcam), you can take snaps directly:

```json

{

"action": "camera_snap",

"node": "raspberry-pi",

"facing": "back"

}

```

Great for home monitoring: "Is the package on my doorstep yet?"

---

Step 5: Remote Access With Tailscale

For all of this to work outside your home network (or to make node communication encrypted and reliable), add Tailscale:

```bash

# On every machine

curl -fsSL https://tailscale.com/install.sh | sh

sudo tailscale up

```

Now use Tailscale IPs instead of local IPs for your gateway URL. Your nodes stay connected even when you're traveling, and all traffic is encrypted end-to-end.

Do NOT use `tailscale funnel` — that exposes your gateway to the public internet. `tailscale serve` is your friend: it keeps everything within your private tailnet.

---

Practical Workflows This Enables

Once your nodes are paired, here are real workflows that become possible:

1. "Compile the iOS app on my Mac"

Your Pi agent SSHs into the Mac (or uses the node run tool) to trigger an Xcode build. No need to touch the Mac.

2. "Run image generation on my GPU"

Trigger Stable Diffusion or ComfyUI on the Windows rig via a node command. Results saved to a shared network folder the Pi can read.

3. "What does my Mac desktop look like right now?"

Screenshot via the node tool. Your agent can check if something is running, a UI looks correct, or an app needs attention.

4. "Run the nightly model fine-tuning job on the GPU rig"

Set a cron job on the Pi that fires at 2 AM and runs a training script on the Windows node. Pure automation.

5. "Check if my 3D print is done"

Pi camera watching the printer → agent takes a snap → describes what it sees → pings you if the print looks done.

---

Troubleshooting Node Connectivity

Node shows offline after pairing:

Commands time out on the Windows node:

Pi gateway can't reach Mac node:

Node pairing request not appearing:

---

The Full Stack: What You've Built

After this setup, you have:

Your single agent on the Pi controls all three. You don't need three separate OpenClaw installs with three separate configs and three sets of API keys. One gateway, multiple nodes.

The tweet author figured this out organically — "TIL" — but now you know going in. Put the Pi on ethernet, pair your nodes, and suddenly your home lab is an agent network.

---

*Have a multi-node setup tip? Drop it in the OpenClaw Discord. The community is building some genuinely wild distributed workflows right now.*

Also fully available in German. 🇩🇪