OpenClaw Nodes: Raspberry Pi, Mac und Windows-GPU-Rig als ein Agent-Netzwerk
Der Tweet, der alles losgetreten hat
Ein Tweet von heute Morgen trifft genau das Thema, das wir uns heute vornehmen:
> *"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!"*
Wenn du OpenClaw bisher nur auf einer Maschine betrieben hast, hast du enormes Potenzial ungenutzt gelassen. Das Nodes-System erlaubt es dir, mehrere Geräte zu verbinden — und dein Hauptagent kann diese Nodes nutzen, um Workloads auszuführen, Screenshots zu machen, Kameras zu verwenden und Befehle auszuführen, als gehörten ihm die Maschinen.
Dieser Post zeigt genau, wie du das einrichtest: Pi als Gehirn, Mac für iOS/Design-Aufgaben, GPU-Rig für schwere Berechnungen.
---
Was sind OpenClaw Nodes?
Nodes sind sekundäre Geräte, die mit deinem OpenClaw-Gateway verbunden werden. Dein Gateway läuft auf der primären Maschine (dem "Gehirn") und orchestriert alles. Nodes sind verbundene Geräte, auf die dein Agent zugreifen kann für:
Der entscheidende Punkt: Die Tools deines Agenten sind nicht auf die Maschine beschränkt, auf der er läuft. Du erhältst ein verteiltes Toolkit über dein gesamtes Heimnetzwerk.
---
Die Architektur: Drei Maschinen, ein Agent
Das Setup, das wir aufbauen:
| Maschine | Rolle | Warum |
|---|---|---|
| Raspberry Pi 5 | Gehirn / Gateway | Immer eingeschaltet, stromsparend (~5W) |
| Mac (iMac/MacBook) | UI-Aufgaben, iOS-Dev, Design | macOS-exklusive Tools, Screenshots |
| Windows + RTX 3080 | Schwere Berechnungen, lokale LLMs | GPU-Workloads, Ollama, Stable Diffusion |
Der Pi betreibt das OpenClaw-Gateway rund um die Uhr. Mac und Windows-Rig sind als Nodes verbunden — sie können schlafen und werden nur geweckt, wenn dein Agent sie braucht.
---
Schritt 1: Gateway auf dem Pi einrichten
Starte mit einem frischen Raspberry Pi 5 (mindestens 4 GB RAM, empfohlen 8 GB). OpenClaw installieren:
```bash
# Auf dem Pi
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
npm install -g openclaw
# Gateway starten
openclaw gateway start
```
Damit der Pi zuverlässig 24/7 läuft, als systemd-Dienst einrichten:
```bash
sudo nano /etc/systemd/system/openclaw.service
```
Inhalt:
```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
```
Dann:
```bash
sudo systemctl daemon-reload
sudo systemctl enable openclaw
sudo systemctl start openclaw
```
Ethernet-Tipp: Der Tweet-Autor hat recht — leg den Pi ans Kabel. WLAN auf dem Pi kann Latenz einführen, wenn dein Agent Tool-Ergebnisse von einem Node streamt. Ethernet macht die Node-Kommunikation reaktionsschnell.
---
Schritt 2: Node-App auf dem Mac installieren
Auf dem Mac die OpenClaw Node-App installieren:
```bash
# Auf dem Mac
npm install -g openclaw
# Als Node starten (kein vollständiges Gateway)
openclaw node start --gateway http://<pi-ip>:PORT
```
Beim ersten Start zeigt das OpenClaw-Dashboard auf dem Pi eine ausstehende Pairing-Anfrage. Genehmigen:
```bash
# Auf dem Pi oder über deinen Agenten
openclaw nodes list # Ausstehende Pairings anzeigen
openclaw nodes approve <node-id>
```
Sobald genehmigt, erscheint dein Mac im `nodes`-Tool deines Agenten. Verifizieren vom Pi:
```bash
openclaw nodes list
# → mac-studio: online | zuletzt gesehen: gerade eben
```
---
Schritt 3: Windows GPU-Rig verbinden
Gleicher Prozess unter Windows. Node.js (v22+) installieren, dann:
```bash
npm install -g openclaw
openclaw node start --gateway http://<pi-ip>:PORT
```
Pairing über den Agenten genehmigen. Jetzt ist das GPU-Rig als Node verfügbar, z. B. als `windows-rig`.
---
Schritt 4: Nodes praktisch nutzen
Dein Agent — laufend auf dem Pi — kann nun für Aufgaben auf beide Nodes zugreifen.
Screenshot vom Mac
```
"Hey Sam, mach mir einen Screenshot von meinem Mac-Bildschirm"
```
Der Agent ruft auf:
```json
{
"action": "screen_record",
"node": "mac-studio",
"durationMs": 1000
}
```
Er nimmt einen Snapshot des Mac-Displays und beschreibt, was er sieht. Nützlich z. B.: "Ist mein Build auf dem Mac fertig?"
Befehl auf dem Windows-Rig ausführen
```
"Starte das Ollama Llama 3.3 70B Modell auf meinem Gaming-Rig"
```
Der Agent ruft auf:
```json
{
"action": "run",
"node": "windows-rig",
"command": ["ollama", "run", "llama3.3:70b"]
}
```
Das startet das Modell auf der RTX 3080 des Windows-Rigs aus der Ferne. Dein Pi-Agent kann dann Anfragen an Ollama stellen, das auf der IP der Windows-Maschine läuft — volle GPU-Power, kein Cloud.
Kamera auf dem Pi selbst nutzen
Wenn dein Pi ein Kameramodul oder eine USB-Webcam hat:
```json
{
"action": "camera_snap",
"node": "raspberry-pi",
"facing": "back"
}
```
Perfekt für Heimüberwachung: "Liegt das Paket schon vor der Tür?"
---
Schritt 5: Remote-Zugriff mit Tailscale
Damit alles außerhalb des Heimnetzwerks funktioniert (oder um die Node-Kommunikation zu verschlüsseln und zuverlässig zu machen), Tailscale hinzufügen:
```bash
# Auf jeder Maschine
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
```
Jetzt Tailscale-IPs statt lokaler IPs für die Gateway-URL verwenden. Die Nodes bleiben verbunden, auch wenn du unterwegs bist, und der gesamte Traffic ist Ende-zu-Ende verschlüsselt.
Wichtig: KEIN `tailscale funnel` — das setzt dein Gateway dem öffentlichen Internet aus. `tailscale serve` ist die richtige Wahl: alles bleibt im privaten Tailnet.
---
Praktische Workflows, die das ermöglicht
1. "Kompiliere die iOS-App auf meinem Mac"
Der Pi-Agent löst über das Node-Tool einen Xcode-Build aus. Kein Anfassen des Macs nötig.
2. "Führe Bildgenerierung auf meiner GPU aus"
Stable Diffusion oder ComfyUI auf dem Windows-Rig via Node-Befehl auslösen. Ergebnisse in einem Netzwerkordner speichern, den der Pi lesen kann.
3. "Wie sieht mein Mac-Desktop gerade aus?"
Screenshot via Node-Tool. Der Agent kann prüfen, ob etwas läuft, eine UI korrekt aussieht oder eine App Aufmerksamkeit braucht.
4. "Führe den nächtlichen Feinabstimmungs-Job auf dem GPU-Rig aus"
Cron-Job auf dem Pi, der um 2 Uhr morgens ein Trainingsskript auf dem Windows-Node startet. Pure Automatisierung.
5. "Ist mein 3D-Druck fertig?"
Pi-Kamera beobachtet den Drucker → Agent macht einen Schnappschuss → beschreibt, was er sieht → benachrichtigt dich, wenn der Druck fertig aussieht.
---
Fehlerbehebung bei der Node-Verbindung
Node zeigt nach dem Pairing offline:
Befehle auf dem Windows-Node haben Timeout:
Pi-Gateway kann Mac-Node nicht erreichen:
Pairing-Anfrage erscheint nicht:
---
Das vollständige Stack: Was du aufgebaut hast
Nach diesem Setup hast du:
Dein einziger Agent auf dem Pi steuert alle drei. Du brauchst keine drei separate OpenClaw-Instanzen mit drei verschiedenen Konfigurationen und drei API-Key-Sets. Ein Gateway, mehrere Nodes.
Der Tweet-Autor hat das organisch entdeckt — "TIL" — aber jetzt weißt du es von Anfang an. Leg den Pi ans Kabel, verbinde deine Nodes, und plötzlich ist dein Heimlabor ein Agent-Netzwerk.
---
*Hast du Tipps für Multi-Node-Setups? Teile sie im OpenClaw Discord. Die Community baut gerade einige wirklich beeindruckende verteilte Workflows.*
Auch vollständig auf Englisch verfügbar. 🇬🇧