Back to skills
SkillHub ClubAnalyze Data & AIFull StackDevOpsData / AI
openclaw-expert
Expert skill for OpenClaw (formerly Clawdbot/MoltBot) — the self-hosted AI agent framework. ALWAYS use when user mentions OpenClaw, Clawdbot, MoltBot, openclaw.json, openclaw gateway, openclaw channels, openclaw nodes, openclaw models, openclaw skills, openclaw doctor, AGENTS.md, SOUL.md, USER.md, HEARTBEAT.md, MEMORY.md, IDENTITY.md, TOOLS.md, BOOTSTRAP.md, ClawHub, clawhub, openclaw workspace, openclaw config, openclaw sessions, openclaw pairing, openclaw docker, openclaw sandbox, openclaw heartbeat, openclaw compaction, memorySearch, multi-agent, bindings, dmPolicy. Covers installation, configuration, troubleshooting, security hardening, channel setup, skill development, memory tuning, Docker deployment. Also trigger for "my bot", "my agent", "Lobster", or agent issues after config changes.
Packaged view
This page reorganizes the original catalog entry around fit, installability, and workflow context first. The original raw source lives below.
Stars
3,111
Hot score
99
Updated
March 20, 2026
Overall rating
C5.2
Composite score
5.2
Best-practice grade
B73.6
Install command
npx @skill-hub/cli install openclaw-skills-openclaw-expert
Repository
openclaw/skills
Skill path: skills/arn0ld87/openclaw-expert
Expert skill for OpenClaw (formerly Clawdbot/MoltBot) — the self-hosted AI agent framework. ALWAYS use when user mentions OpenClaw, Clawdbot, MoltBot, openclaw.json, openclaw gateway, openclaw channels, openclaw nodes, openclaw models, openclaw skills, openclaw doctor, AGENTS.md, SOUL.md, USER.md, HEARTBEAT.md, MEMORY.md, IDENTITY.md, TOOLS.md, BOOTSTRAP.md, ClawHub, clawhub, openclaw workspace, openclaw config, openclaw sessions, openclaw pairing, openclaw docker, openclaw sandbox, openclaw heartbeat, openclaw compaction, memorySearch, multi-agent, bindings, dmPolicy. Covers installation, configuration, troubleshooting, security hardening, channel setup, skill development, memory tuning, Docker deployment. Also trigger for "my bot", "my agent", "Lobster", or agent issues after config changes.
Open repositoryBest for
Primary workflow: Analyze Data & AI.
Technical facets: Full Stack, DevOps, Data / AI, Security.
Target audience: everyone.
License: Unknown.
Original source
Catalog source: SkillHub Club.
Repository owner: openclaw.
This is still a mirrored public skill entry. Review the repository before installing into production workflows.
What it helps with
- Install openclaw-expert into Claude Code, Codex CLI, Gemini CLI, or OpenCode workflows
- Review https://github.com/openclaw/skills before adding openclaw-expert to shared team environments
- Use openclaw-expert for development workflows
Works across
Claude CodeCodex CLIGemini CLIOpenCode
Favorites: 0.
Sub-skills: 0.
Aggregator: No.
Original source / Raw SKILL.md
---
name: openclaw-expert
description: >
Expert skill for OpenClaw (formerly Clawdbot/MoltBot) — the self-hosted AI agent framework.
ALWAYS use when user mentions OpenClaw, Clawdbot, MoltBot, openclaw.json, openclaw gateway,
openclaw channels, openclaw nodes, openclaw models, openclaw skills, openclaw doctor,
AGENTS.md, SOUL.md, USER.md, HEARTBEAT.md, MEMORY.md, IDENTITY.md, TOOLS.md, BOOTSTRAP.md,
ClawHub, clawhub, openclaw workspace, openclaw config, openclaw sessions, openclaw pairing,
openclaw docker, openclaw sandbox, openclaw heartbeat, openclaw compaction, memorySearch,
multi-agent, bindings, dmPolicy. Covers installation, configuration, troubleshooting,
security hardening, channel setup, skill development, memory tuning, Docker deployment.
Also trigger for "my bot", "my agent", "Lobster", or agent issues after config changes.
---
# OpenClaw Expert Skill
## Kernprinzip: Docs-First + Backup-First
OpenClaw verwendet CalVer-Versioning (YYYY.M.D-N) und ändert sich häufig.
**Vor jeder Änderung** diese Checkliste abarbeiten:
1. **Version prüfen**: `openclaw --version`
2. **Live-Docs holen** — `web_fetch` auf relevante Docs-Seiten (URLs in Referenzdateien)
3. **Community-Tipps suchen** — `web_search` nach aktuellen Workarounds
4. **Backup anlegen** — Niemals Konfig ohne Backup ändern
5. **Änderung durchführen**
6. **Validieren** — `openclaw doctor` vor und nach jeder Änderung
7. **Gateway neu starten** — `systemctl --user restart openclaw-gateway`
8. **Testen** — `openclaw status` + Kanal-Test
---
## Architektur auf einen Blick
```
Messaging-Kanäle (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, Matrix, Google Chat, Zalo, WebChat…)
│
▼
┌───────────────────────────────┐
│ Gateway │ ← ws://127.0.0.1:18789
│ (Control-Plane, RPC) │ ← Config: ~/.openclaw/openclaw.json (JSON5)
│ systemd user service │ ← Dashboard: http://127.0.0.1:18789
└──────────────┬────────────────┘
│
┌──────┴──────┐
│ Agent(s) │ ← Workspace: ~/.openclaw/workspace/
│ Runtime │ ← Sessions: ~/.openclaw/agents/<id>/sessions/
└──────┬──────┘
│
┌──────┴──────────────────────────┐
│ Nodes (optional) │
│ iOS / Android / macOS / Pi │
│ + Canvas / A2UI │
└─────────────────────────────────┘
```
### Verzeichnisstruktur
```
~/.openclaw/
├── openclaw.json # Haupt-Config (JSON5 – Kommentare + trailing commas!)
├── credentials/ # API-Keys (chmod 600!)
│ ├── anthropic
│ ├── openai
│ └── openrouter
├── agents/
│ └── <agentId>/
│ └── sessions/ # Session-Logs (*.jsonl)
├── skills/ # Managed/lokale Skills
└── workspace/ # Agent-Workspace (= das "Gehirn")
├── AGENTS.md # Betriebsanweisungen (in JEDER Session geladen)
├── SOUL.md # Persönlichkeit, Ton, Grenzen (jede Session)
├── USER.md # Nutzerprofil (jede Session)
├── TOOLS.md # Tool-Hinweise (jede Session)
├── IDENTITY.md # Name, Emoji, Vibe
├── HEARTBEAT.md # Scheduled-Tasks / Cron-Checkliste
├── MEMORY.md # Langzeit-Gedächtnis (nur private Sessions!)
├── BOOTSTRAP.md # Einmal-Setup (nach Ausführung gelöscht)
├── memory/ # Tages-Logs (YYYY-MM-DD.md)
├── skills/ # Workspace-Skills
└── .git/ # Git-Backup (empfohlen!)
```
---
## Referenzdateien — Wann was lesen
Dieses Skill-Paket enthält detaillierte Referenzdateien. **Lies die relevante Datei
BEVOR du eine Aktion durchführst.** Die Dateien liegen unter `references/` im Skill-Verzeichnis.
| Aufgabe | Referenzdatei | Inhalt |
|---|---|---|
| Installation & erste Schritte | `references/installation.md` | npm/pnpm, Docker, VPS-Setup, Onboarding-Wizard |
| openclaw.json bearbeiten | `references/config-reference.md` | Vollständige Feld-Referenz basierend auf realer Config (auth, models, agents, tools, gateway…) |
| Dashboard (Control UI) | `references/dashboard.md` | Alle Dashboard-Bereiche, Zugriff, Troubleshooting |
| Workspace-Dateien schreiben | `references/workspace-files.md` | AGENTS.md, SOUL.md, USER.md, HEARTBEAT.md, MEMORY.md Templates |
| Channels einrichten | `references/channels.md` | Telegram (komplett!), WhatsApp, Discord, Slack, Signal + Troubleshooting |
| Memory & Compaction tunen | `references/memory-system.md` | memoryFlush, memorySearch, Compaction, Semantic Search, Decay |
| Docker-Deployment | `references/docker-setup.md` | docker-compose, Sandbox, alpine/openclaw, Permissions |
| Security-Hardening | `references/security-hardening.md` | dmPolicy, Token-Rotation, Allowlists, Sandboxing, CIS-Style |
| Skills entwickeln/installieren | `references/skills-guide.md` | SKILL.md-Format, ClawHub, Workspace-Skills, Security-Review |
| Multi-Agent-Routing | `references/multi-agent.md` | agents.list, bindings, accountId, agentId, Isolation |
| CLI-Referenz | `references/cli-reference.md` | Alle Befehle mit Syntax und Beispielen |
| Dashboard / Control UI | `references/dashboard.md` | Sidebar-Navigation, Bereiche, CORS, Config, Troubleshooting |
| Nodes & Remote-Zugriff | `references/nodes-and-remote.md` | Node-Typen, Pairing, Headless-Nodes, Bonjour/mDNS, Exec-Approvals |
| Tailscale-Integration | `references/tailscale-integration.md` | Serve vs Funnel vs Tailnet-Bind, SSH-Tunnel, Auth, Config-Beispiele |
| Praxis-Beispiele | `references/examples.md` | 7 vollständige Setup-Szenarien (Einsteiger → Multi-Agent → Kosten-optimiert) |
| Troubleshooting | `references/troubleshooting.md` | Häufige Fehler, Logs, Diagnose-Schritte |
| Tricks & Power-User | `references/tricks-and-hacks.md` | Community-Tipps, Cost-Saving, Obsidian, Surge, Watchdog |
---
## Schnellreferenz: Wichtigste CLI-Befehle
```bash
# Status & Diagnose
openclaw --version # CalVer-Version
openclaw doctor # Gesundheitscheck (IMMER!)
openclaw doctor --fix # Auto-Fix
openclaw status # Kurzer Status
openclaw dashboard # Browser-UI (Port 18789)
# Gateway
openclaw gateway start|stop|restart|status
openclaw gateway install # systemd user service
openclaw gateway log # Logs (= journalctl --user -u openclaw-gateway -f)
# Channels
openclaw channels list|add|remove|restart
openclaw channels status --probe # Live-Check
# Models
openclaw models list|set <provider/model>
# Skills
openclaw skills list|reload
clawhub search|install|update <name>
# Memory & Sessions
openclaw sessions list|clean
openclaw memory flush
# Update
pnpm add -g openclaw@latest && pnpm approve-builds -g && openclaw doctor
# Nodes & Devices
openclaw nodes status # Verbundene Nodes anzeigen
openclaw nodes describe --all # Node-Capabilities auflisten
openclaw nodes run --node <id> -- <cmd> # Befehl auf Node ausführen
openclaw devices list # Pairing-Requests anzeigen
openclaw devices approve <requestId> # Node-Pairing genehmigen
# Channel-Pairing
openclaw pairing list|approve <channel> <code>
# Config
openclaw config list|get|set|validate
# Security
openclaw token:rotate --force --length 64
openclaw security audit --deep
```
---
## Sicherheits-Grundregeln (IMMER beachten!)
1. **Gateway bind: `loopback`** — Niemals `lan` oder `0.0.0.0` ohne Tailscale/VPN
2. **dmPolicy: `allowlist`** — Niemals `open` in Produktion
3. **Token: mindestens 64 Zeichen** — `openclaw token:rotate --force --length 64`
4. **Credentials: `chmod 600`** — `chmod 600 ~/.openclaw/credentials/*`
5. **Skills reviewen** — Vor Installation Quellcode prüfen, ClawHub "Hide Suspicious" nutzen
6. **Kein root** — OpenClaw als eigener User betreiben
7. **Workspace = privat** — Git-Backup in **privates** Repo, MEMORY.md nie in Groups laden
8. **API-Spending-Limits** — Beim Provider setzen, bevor Heartbeat aktiviert wird
9. **Sandbox für Tools** — `tools.exec.host: "sandbox"` wenn möglich
---
## Workflow: Docs nachschlagen
### Offizielle Docs-URLs (für web_fetch)
```
https://docs.openclaw.ai # Hauptseite
https://docs.openclaw.ai/install/docker # Docker
https://docs.openclaw.ai/concepts/agent-workspace # Workspace
https://docs.openclaw.ai/concepts/memory # Memory
https://docs.openclaw.ai/concepts/multi-agent # Multi-Agent
https://docs.openclaw.ai/channels/<name> # Channel-Guides
https://docs.openclaw.ai/models # Models
https://docs.openclaw.ai/tools/skills # Skills
https://docs.openclaw.ai/security # Security
```
Alternative Docs-Mirror: `https://openclaw.im/docs/`
### Community-Suche (für web_search)
```
"openclaw <Thema> 2026 tips"
"openclaw <Problem> fix workaround github issue"
"openclaw.json <Section> advanced configuration"
```
Quellen-Priorität:
1. `github.com/openclaw/openclaw` (Issues, Discussions, AGENTS.md)
2. `docs.openclaw.ai` / `openclaw.im/docs`
3. Community-Guides (Simon Willison TIL, Substack, Medium)
4. Reddit r/selfhosted, Hacker News
---
## Backup-Strategie (IMMER vor Änderungen)
```bash
# Snapshot der Config
cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bak
# Versioniertes Backup
tar czf ~/openclaw-backup-$(date +%Y%m%d_%H%M%S).tar.gz ~/.openclaw/
# Git-Backup des Workspace (empfohlen)
cd ~/.openclaw/workspace && git add -A && git commit -m "backup: $(date +%Y%m%d_%H%M%S)"
```
---
## Protokoll: Sichere Config-Änderung
1. `openclaw --version` → Version notieren
2. Relevante Referenzdatei lesen (siehe Tabelle oben)
3. Live-Docs fetchen (URLs oben)
4. `cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bak`
5. Änderung durchführen
6. `openclaw doctor`
7. `systemctl --user restart openclaw-gateway`
8. `openclaw status` + Funktionstest im Channel
9. Bei Fehler: `cp ~/.openclaw/openclaw.json.bak ~/.openclaw/openclaw.json && systemctl --user restart openclaw-gateway`
---
## Referenced Files
> The following files are referenced in this skill and included for context.
### references/installation.md
```markdown
# Installation & Erste Schritte
## Voraussetzungen
- Node.js 22+ (required)
- macOS, Linux, oder Windows (via WSL2, dringend empfohlen)
- 2 GB RAM minimum (4 GB empfohlen)
- 10 GB+ Disk
---
## Methode 1: npm/pnpm (empfohlen für lokale Nutzung)
```bash
# pnpm (empfohlen):
corepack enable
pnpm add -g openclaw@latest
pnpm approve-builds -g
# oder npm:
npm install -g openclaw@latest
# Onboarding-Wizard starten:
openclaw onboard
```
Der Wizard fragt ab:
1. Gateway bind-Modus (→ `loopback` wählen!)
2. Auth-Modus (→ `token` wählen!)
3. Gateway-Token
4. Tailscale? (→ Off, es sei denn du nutzt Tailscale)
5. AI-Provider (Anthropic/OpenAI/Ollama)
6. API-Key
7. Channel-Setup (WhatsApp/Telegram/Discord)
8. Gateway als Daemon installieren?
Nach dem Wizard:
```bash
openclaw doctor # Check
openclaw status # Status
openclaw dashboard # Browser-UI
```
---
## Methode 2: Docker (empfohlen für VPS/Server)
```bash
git clone https://github.com/openclaw/openclaw.git
cd openclaw
bash docker-setup.sh
```
Das Script:
1. Baut das Docker-Image
2. Startet den Onboarding-Wizard (interaktiv)
3. Konfiguriert Docker Compose
4. Startet den Gateway-Container
### Docker-Compose-Befehle
```bash
# Gateway starten
docker compose up -d openclaw-gateway
# CLI-Befehle ausführen
docker compose run --rm openclaw-cli doctor
docker compose run --rm openclaw-cli channels add --channel telegram --token <TOKEN>
docker compose run --rm openclaw-cli dashboard --no-open
# Logs
docker compose logs -f openclaw-gateway
# Shell im Container
docker compose exec openclaw-gateway bash
# Als root (für Paketinstallation):
docker compose exec -u root openclaw-gateway bash
```
### Alternative Docker-Images
```bash
# Alpine-basiertes Community-Image:
docker pull alpine/openclaw:latest
# Phioranex Community-Image mit install-Script:
curl -fsSL https://raw.githubusercontent.com/phioranex/openclaw-docker/main/install.sh | sudo bash
```
### Docker-Volumes
```
~/.openclaw → /home/node/.openclaw (Config, Sessions, Credentials)
~/openclaw/workspace → /home/node/.openclaw/workspace (Agent-Workspace)
```
### Docker + Ollama (lokale Modelle)
```json5
// In openclaw.json:
models: {
providers: {
ollama: {
// Auf macOS mit Docker Desktop:
baseUrl: "http://host.docker.internal:11434",
// Auf Linux:
baseUrl: "http://172.17.0.1:11434",
},
},
},
```
---
## Methode 3: DigitalOcean 1-Click
DigitalOcean bietet ein vorkonfiguriertes Droplet-Image mit:
- OpenClaw vorinstalliert
- Docker-Container-Isolation
- Non-Root-User-Execution
- Hardened Firewall
---
## Methode 4: Docker Sandbox (maximale Isolation)
```bash
docker sandbox create --name my-openclaw shell .
docker sandbox network proxy my-openclaw --allow-host localhost
docker sandbox run my-openclaw
# Im Sandbox:
npm install -g n && n 22
hash -r
npm install -g openclaw@latest
openclaw setup
```
Vorteile: Micro-VM-Isolation, API-Key-Injection über Network-Proxy (Keys nie im Container).
---
## Nach der Installation
1. **API-Key einrichten**: Provider wählen (Anthropic empfohlen)
2. **Channel verbinden**: Mindestens einen Messaging-Kanal einrichten
3. **Pairing durchführen**: `openclaw pairing approve <channel> <code>`
4. **Workspace personalisieren**: SOUL.md, USER.md, AGENTS.md anpassen
5. **Security-Check**: `openclaw doctor`, dmPolicy auf `allowlist` prüfen
6. **Test-Nachricht senden**: Im gewählten Kanal den Bot anschreiben
---
## Update
```bash
# pnpm (empfohlen):
pnpm add -g openclaw@latest && pnpm approve-builds -g && openclaw doctor
# npm:
npm install -g openclaw@latest && openclaw doctor
# Docker:
cd openclaw && git pull && bash docker-setup.sh
```
**Nach jedem Update**: `openclaw doctor` ausführen!
```
### references/config-reference.md
```markdown
# Config-Referenz — openclaw.json vollständig
## Datei & Format
- Pfad: `~/.openclaw/openclaw.json`
- Format: **JSON5** (Kommentare `//`, trailing commas erlaubt)
- Hot-Reload: Gateway beobachtet die Datei und wendet Änderungen automatisch an
- Ausnahme: `gateway.reload` und `gateway.remote` triggern KEINEN Restart
- Validierung: `openclaw config validate`
---
## Alle Top-Level Sections
```
meta / wizard / update / auth / models / agents / tools / messages /
commands / session / hooks / channels / canvasHost / gateway / skills / plugins
```
---
## meta
Automatisch verwaltet — nicht manuell editieren.
```json5
{
meta: {
lastTouchedVersion: "2026.2.26",
lastTouchedAt: "2026-02-28T06:10:52.119Z",
},
}
```
---
## wizard
Tracking des Setup-Wizards — nicht manuell editieren.
```json5
{
wizard: {
lastRunAt: "...",
lastRunVersion: "2026.2.26",
lastRunCommand: "configure", // "setup" | "configure" | "onboard"
lastRunMode: "local", // "local" | "remote"
},
}
```
---
## update
```json5
{
update: {
channel: "stable", // "stable" | "beta" | "nightly"
auto: { enabled: true },
},
}
```
`beta` für neue Features, `stable` für Produktion.
---
## auth — Provider-Authentifizierung
Auth-Profile pro LLM-Provider. Key-Format: `provider:label`.
```json5
{
auth: {
profiles: {
// API-Key (häufigster Fall)
"deepseek:default": { provider: "deepseek", mode: "api_key" },
"mistral:default": { provider: "mistral", mode: "api_key" },
"google:default": { provider: "google", mode: "api_key" },
"nvidia:default": { provider: "nvidia", mode: "api_key" },
"deepgram:default": { provider: "deepgram", mode: "api_key" },
// OAuth/Token
"github-copilot:github": { provider: "github-copilot", mode: "token" },
"openai-codex:default": { provider: "openai-codex", mode: "oauth" },
"anthropic:default": { provider: "anthropic", mode: "token" },
"google-antigravity:[email protected]": {
provider: "google-antigravity", mode: "oauth", email: "[email protected]",
},
// Lokal (Ollama — Key meist leer/dummy)
"ollama:default": { provider: "ollama", mode: "api_key" },
},
},
}
```
### Bekannte Provider
| Provider | API-Typ | Auth | Modelle |
|---|---|---|---|
| `anthropic` | anthropic-messages | api_key/token | Claude Sonnet/Opus/Haiku |
| `openai-codex` | openai | oauth | GPT-5.x Codex |
| `github-copilot` | openai | token | GPT-5.x, GPT-4.1 |
| `google` | google-generative-ai | api_key | Gemini 3 Pro/Flash |
| `google-antigravity` | google-generative-ai | oauth | Antigravity-Modelle |
| `deepseek` | openai-completions | api_key | V3, R1, V3.2, V3.2-Speciale |
| `moonshot` | openai-completions | api_key | Kimi K2.5 |
| `mistral` | openai-completions | api_key | Mistral Large |
| `nvidia` | openai-completions | api_key | NIM: Kimi, Qwen, DeepSeek |
| `ollama` | openai-completions | api_key | Lokal + Cloud (`:cloud` Suffix) |
| `deepgram` | deepgram | api_key | Audio: Nova-3 |
---
## models — LLM-Provider & Modelle
```json5
{
models: {
mode: "merge", // "merge" = mit Defaults zusammenführen | "replace" = nur eigene
providers: {
"<provider-name>": {
baseUrl: "https://...", // API-Endpoint
api: "openai-completions", // API-Typ (siehe Tabelle)
// apiKey: "<key>", // Optional direkt hier (besser: credentials/)
// auth: "api-key", // Explizite Auth-Methode
models: [
{
id: "model-id", // Unique ID
name: "Anzeigename", // Für Dashboard/Chat
reasoning: false, // true = CoT/Reasoning-Modell
input: ["text"], // ["text"] | ["text", "image"]
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
contextWindow: 200000,
maxTokens: 8192,
api: "openai-completions", // Kann pro Modell überschrieben werden
},
],
},
},
},
}
```
### API-Typen
| api | Für |
|---|---|
| `anthropic-messages` | Anthropic (Claude) |
| `openai-completions` | OpenAI-kompatibel (DeepSeek, Mistral, NVIDIA, Ollama, Moonshot) |
| `google-generative-ai` | Google (Gemini, Antigravity) |
### Trick: Gleiche baseUrl, verschiedene API-Keys
Wenn verschiedene NVIDIA-Modelle verschiedene Keys brauchen:
```json5
"nvidia": { baseUrl: "https://integrate.api.nvidia.com/v1", models: [...] },
"nvidia-deepseek": { baseUrl: "https://integrate.api.nvidia.com/v1", models: [...] },
"nvidia-qwen": { baseUrl: "https://integrate.api.nvidia.com/v1", models: [...] },
```
### Trick: Ollama Cloud-Modelle
Ollama kann Cloud-Modelle proxyen — kostenfrei, kein eigener API-Key:
```json5
"ollama": {
baseUrl: "http://localhost:11434/v1",
models: [
{ id: "kimi-k2.5:cloud", name: "Kimi K2.5 (Cloud)", reasoning: true, contextWindow: 262144 },
{ id: "deepseek-v3.2:cloud", name: "DeepSeek V3.2 (Cloud)", reasoning: true },
{ id: "qwen3.5:397b-cloud", name: "Qwen 3.5 397B (Cloud)", reasoning: true },
// Vision-Modell
{ id: "qwen3-vl:235b-instruct-cloud", input: ["text", "image"] },
],
}
```
---
## agents — Agent-Konfiguration
```json5
{
agents: {
defaults: {
model: {
primary: "openai-codex/gpt-5.3-codex", // Standard-Modell
},
// Modelle mit Aliases (für /model <alias>)
models: {
"anthropic/claude-sonnet-4-6": { alias: "Sonnet" },
"deepseek/deepseek-reasoner": { alias: "R1" },
"ollama/kimi-k2.5:cloud": { alias: "Ollama-Kimi" },
"google/gemini-3-pro-preview": { alias: "gemini" },
// Ohne alias: /model google/gemini-3-pro-high (voller Pfad)
},
workspace: "/home/admin/.openclaw/workspace",
// Context-Pruning: alte Tool-Ergebnisse entfernen
contextPruning: {
mode: "cache-ttl", // "cache-ttl" | "none"
ttl: "1h", // Cache-Lebensdauer
},
// Compaction
compaction: {
mode: "safeguard", // "safeguard" | "aggressive" | "manual"
},
timeoutSeconds: 1800, // LLM-Timeout (30 Min)
heartbeat: { every: "1h" }, // "30m" | "1h" | "4h" | "12h" | "24h"
maxConcurrent: 4, // Max parallele Tool-Aufrufe
subagents: { maxConcurrent: 8 },
},
},
}
```
### Compaction-Modi
| Modus | Verhalten | Kosten |
|---|---|---|
| `safeguard` | Auto bei ~80% Context-Limit | Moderat |
| `aggressive` | Häufiger compacten | Spart Tokens |
| `manual` | Nur mit `/compact` | Volle Kontrolle |
---
## tools
```json5
{
tools: {
web: {
search: { enabled: false, apiKey: "<brave/tavily-key>" },
fetch: { enabled: true },
},
media: {
audio: {
enabled: true,
maxBytes: 20971520, // 20 MB
providerOptions: {
deepgram: { detect_language: true, punctuate: true, smart_format: true },
},
models: [{ provider: "deepgram", model: "nova-3" }],
},
},
sessions: { visibility: "all" }, // "all" | "own" | "none"
},
}
```
---
## messages — TTS & Reaktionen
```json5
{
messages: {
tts: {
provider: "edge", // "edge" | "elevenlabs" | "openai"
edge: { enabled: true, voice: "de-DE-ConradNeural", lang: "de-DE" },
},
ackReactionScope: "group-mentions", // "all" | "group-mentions" | "none"
},
}
```
Deutsche Edge-TTS-Stimmen: `de-DE-ConradNeural` (m), `de-DE-KatjaNeural` (w),
`de-DE-AmalaNeural` (w), `de-DE-FlorianMultilingualNeural` (m).
---
## commands / session / hooks
```json5
{
commands: {
native: "auto", // Slash-Commands
nativeSkills: "auto", // Skill-Commands
restart: true, // /restart erlauben
ownerDisplay: "raw", // "raw" | "masked" | "hidden"
},
session: {
dmScope: "per-channel-peer", // "per-channel-peer" | "global" | "per-channel"
},
hooks: {
internal: {
enabled: true,
entries: {
"boot-md": { enabled: true },
"bootstrap-extra-files": { enabled: true },
"command-logger": { enabled: true },
"session-memory": { enabled: true },
},
},
},
}
```
---
## channels — Messaging-Kanäle
```json5
{
channels: {
whatsapp: {
enabled: true,
dmPolicy: "allowlist",
selfChatMode: true,
allowFrom: ["+4915568920209"], // E.164-Format MIT +
groupPolicy: "allowlist",
debounceMs: 0,
mediaMaxMb: 50,
},
telegram: {
enabled: true,
dmPolicy: "allowlist",
botToken: "<von-BotFather>",
allowFrom: [7403482253], // Telegram User-ID (ZAHL, kein String!)
groupPolicy: "allowlist",
streaming: "partial", // "partial" | "full" | "off"
mediaMaxMb: 50,
},
},
}
```
### dmPolicy
| Wert | Bedeutung | Produktion? |
|---|---|---|
| `allowlist` | Nur `allowFrom` | ✅ Immer |
| `open` | Jeder | ⚠️ Nur Tests |
| `closed` | Keine DMs | Gruppen-only |
**ACHTUNG**: WhatsApp dmPolicy gilt **GLOBAL** für den Account!
---
## gateway
```json5
{
gateway: {
port: 18789,
mode: "local", // "local" | "remote"
bind: "loopback", // "loopback" | "lan" | "tailnet" | "custom"
controlUi: {
// enabled: true,
allowedOrigins: ["https://hostname.taildcb944.ts.net"], // CORS!
},
auth: {
mode: "token",
token: "<token>", // Besser: OPENCLAW_GATEWAY_TOKEN env
allowTailscale: true,
},
trustedProxies: ["100.64.0.0/10"], // Tailscale CGNAT — PFLICHT für allowTailscale!
tailscale: {
mode: "serve", // "off" | "serve" | "funnel"
resetOnExit: false,
},
},
}
```
---
## skills / plugins
```json5
{
skills: {
entries: {
"gh-issues": { apiKey: "<github-token>" },
"peekaboo": { enabled: true },
},
},
plugins: {
entries: {
telegram: { enabled: true },
whatsapp: { enabled: true },
},
},
}
```
---
## Häufige Config-Fehler
| Fehler | Symptom | Fix |
|---|---|---|
| `allowFrom` als String statt Array | Channel startet nicht | `["+49..."]` (Array!) |
| Telegram allowFrom als String | Keine Nachrichten | `[7403482253]` (Zahl!) |
| WhatsApp ohne Ländercode | Keine Nachrichten | `"+4915568920209"` (E.164) |
| `bind: "lan"` ohne Auth | Gateway-Start verweigert | Auth setzen |
| Doppelte Modell-IDs | Unvorhersehbar | Jede ID nur 1x |
| `trustedProxies` fehlt | allowTailscale ignoriert | `["100.64.0.0/10"]` |
| `allowedOrigins` fehlt | CORS im Dashboard | Tailscale-Domain eintragen |
| Provider ≠ auth.profiles Key | Auth fehlschlag | Namen abgleichen |
| `cost: 0` bei Ollama Cloud | Falsche Kostenanzeige | Korrekt — Cloud-Modelle sind gratis |
---
## Validierung
```bash
openclaw config validate # Syntax + Struktur prüfen
openclaw config get <pfad> # Einzelnen Wert lesen
openclaw config edit # Im Editor öffnen
openclaw doctor # Gesundheitscheck nach Änderung
```
```
### references/dashboard.md
```markdown
# Dashboard / Control UI — Vollständige Referenz
## Zugriff
```
http://127.0.0.1:18789/ # Lokal
https://<host>.ts.net/ # Via Tailscale Serve
```
Config: `gateway.controlUi.enabled: true` (Default)
---
## Sidebar-Navigation
### 💬 Chat
WebChat direkt im Browser. Gleiche Funktionen wie Telegram/WhatsApp.
Nützlich für Tests, Debug und wenn kein Kanal eingerichtet ist.
Unterstützt Media-Upload, Slash-Commands, Streaming.
### Control-Bereich
**📊 Overview** — Gateway-Status, aktive Sessions, Channels, Primary Model, Uptime, Version, Token-Übersicht.
**🔗 Channels** — Liste aller Channels mit Status (connected/error/disabled). Aktionen: Restart, Disconnect. WhatsApp-QR für Pairing. Telegram-Webhook-Status.
**((o)) Instances** — Laufende Gateway-Instanzen mit PID, Startzeit. Meist nur 1 Instanz.
**📄 Sessions** — Aktive + archivierte Sessions. Filter nach Channel/Agent/Zeitraum. Pro Session: Model, Tokens, Kosten. Aktionen: Inspect, Compact, Clean.
**📊 Usage** — Token-Verbrauch pro Modell/Provider. Kosten-Aufschlüsselung. Heartbeat-Kosten separat.
**✨ Cron Jobs** — Heartbeat-Status, Verlauf, nächster geplanter Run. Webhook-Wakeups.
### Agent-Bereich
**📁 Agents** — Agent-Liste (Multi-Agent). Bindings (Channel → Agent). Workspace-Dateien anzeigen/editieren.
**⚡ Skills** — Installierte Skills (Bundled/Managed/Workspace). Status, ClawHub-Suche, Reload.
**🖥️ Nodes** — Verbundene Nodes mit Capabilities. Pairing genehmigen/ablehnen. Details: Typ, IP, Last Seen.
### Settings-Bereich
**⚙️ Config** — openclaw.json im Browser editieren. JSON5-Highlighting, Validierung, Hot-Reload.
**🔧 Debug** — Echtzeit-Event-Stream. Tool-Aufrufe mit I/O. Session-State. Agent-Reasoning.
**📋 Logs** — Gateway-Logs mit Level-Filter (error/warn/info/debug). Echtzeit-Streaming.
### Resources
**📖 Docs** — Link zur offiziellen Dokumentation.
---
## Dashboard-Konfiguration
### CORS für Tailscale (PFLICHT bei Serve!)
```json5
{
gateway: {
controlUi: {
allowedOrigins: ["https://hostname.taildcb944.ts.net"],
},
},
}
```
### Custom Base Path
```json5
{ gateway: { controlUi: { basePath: "/dashboard/" } } }
```
### Assets bauen (Git-Installation)
```bash
pnpm install && pnpm build:control-ui
ls dist/control-ui/ # Prüfen: index.html vorhanden?
```
npm/pnpm-Installation: Assets bereits enthalten.
---
## Troubleshooting
| Problem | Lösung |
|---|---|
| Leere Seite | `pnpm build:control-ui` |
| CORS-Fehler | `allowedOrigins` setzen |
| Auth-Fehler | Token prüfen, `allowTailscale` + `trustedProxies` |
| "device identity required" | HTTPS nötig → Tailscale Serve |
| Port nicht erreichbar | `ss -tlnp \| grep 18789` |
| WebSocket-Fehler | `trustedProxies: ["100.64.0.0/10"]` |
```
### references/workspace-files.md
```markdown
# Workspace-Dateien — Templates & Best Practices
> Alle Dateien unter `~/.openclaw/workspace/` werden bei jedem Session-Start geladen.
> `MEMORY.md` nur in privaten Sessions, nie in Gruppen.
## Datei-Übersicht
| Datei | Geladen | Zweck |
|---|---|---|
| AGENTS.md | Jede Session | Betriebsanweisungen, Regeln, Prioritäten |
| SOUL.md | Jede Session | Persönlichkeit, Ton, Grenzen |
| USER.md | Jede Session | Nutzerprofil, Anrede, Präferenzen |
| TOOLS.md | Jede Session | Tool-spezifische Hinweise |
| IDENTITY.md | Jede Session | Name, Emoji, Vibe |
| HEARTBEAT.md | Jeder Heartbeat | Scheduled-Tasks-Checkliste |
| MEMORY.md | Nur privat | Langzeit-Gedächtnis (kuratiert, ~100 Zeilen) |
| BOOTSTRAP.md | Einmalig | Erstes Setup, wird nach Ausführung gelöscht |
| memory/*.md | Über memorySearch | Tages-Logs (YYYY-MM-DD.md) |
---
## AGENTS.md — Template
```markdown
# Betriebsanweisungen
## Kernregeln
- Antworte kurz und präzise. Keine langen Erklärungen wenn nicht explizit gefragt.
- Führe Befehle aus, frage nicht doppelt nach Bestätigung.
- Bei destruktiven Aktionen (Dateien löschen, Mails senden): IMMER erst fragen.
- Bei CLI-Fehlern: `--help` nutzen, nicht raten.
- Maximale Iterations bei Tool-Loops: 5. Dann stoppen und berichten.
## Prioritäten
1. Sicherheit — Keine API-Keys leaken, keine unbekannten Befehle blind ausführen
2. Korrektheit — Lieber "ich bin mir unsicher" als falsche Antwort
3. Effizienz — Wenige Tool-Calls, direkte Lösung
## Memory-Regeln
- Wichtige Entscheidungen → MEMORY.md
- Tagesnotizen → memory/YYYY-MM-DD.md
- "Merke dir X" → Sofort in die passende Datei schreiben, nicht im RAM halten
## Gruppen-Verhalten
- In Gruppen: Nur antworten wenn direkt angesprochen oder @erwähnt
- Nie mit der Stimme des Users sprechen
- Nie MEMORY.md-Inhalte in Gruppen preisgeben
```
---
## SOUL.md — Template
```markdown
# Persönlichkeit
Du bist [Name], der persönliche AI-Assistent von [User].
## Ton & Stil
- Direkt, sachlich, freundlich
- Deutsch als Hauptsprache, Englisch bei Tech-Begriffen OK
- Keine Emojis außer bei expliziter Aufforderung
- Keine Floskeln ("Gerne!", "Klar doch!")
## Grenzen
- Ich bin ein Tool, kein Freund. Keine emotionalen Bindungen aufbauen.
- Bei medizinischen/rechtlichen Fragen: "Bitte einen Fachmann konsultieren"
- Keine Meinungen zu Politik oder Religion
## Spezialgebiete
- Linux-Administration, Docker, DevOps
- [Weitere Fachgebiete des Users einfügen]
```
---
## USER.md — Template
```markdown
# Nutzerprofil
## Anrede
- Name: [Vorname]
- Anrede: Du
## Kontext
- Beruf: [Beruf/Rolle]
- Tech-Stack: [z.B. Linux, Docker, Python]
- Betriebssystem: [z.B. macOS, Ubuntu 24.04]
## Präferenzen
- Bevorzugte Sprache: Deutsch
- Code-Snippets: Mit kurzen Kommentaren
- Antwortlänge: Kurz und actionable
```
---
## HEARTBEAT.md — Template
```markdown
# Heartbeat-Checkliste
Prüfe bei jedem Heartbeat:
## Tägliche Aufgaben
- [ ] Neue Nachrichten in ungelesenen Channels prüfen
- [ ] Erinnerungen für heute checken (memory/heute.md)
- [ ] Wetter-Update für [Stadt] bereitstellen (wenn konfiguriert)
## Wöchentliche Aufgaben
- [ ] Memory aufräumen (alte Tagesnotizen konsolidieren → MEMORY.md)
- [ ] Workspace-Status prüfen (Speicherplatz, Session-Count)
## Regeln
- Wenn kein Task ansteht: "HEARTBEAT_OK" antworten (wird vom Gateway verworfen)
- Nie unaufgefordert Nachrichten senden wenn nichts zu tun ist
- Bei Fehlern: In memory/ loggen, User nicht stören
```
**Heartbeat-Konfiguration** (in openclaw.json):
```json5
agent: {
heartbeat: {
every: "30m", // Intervall: "30m" | "1h" | "6h" | "off"
target: "last", // "last" = in letzter Session | "isolated" = eigene Session
},
}
```
**Kosten-Warnung**: Heartbeat alle 30min mit Claude verursacht ~$0.50-2.00/Tag.
Mit Anthropic OAuth ist das Minimum 1h. API-Spending-Limits beim Provider setzen!
---
## IDENTITY.md — Template
```markdown
name: Clawd
emoji: 🦞
vibe: helpful, concise, technical
```
---
## MEMORY.md — Best Practices
- Max. ~100 Zeilen halten (wird in jede private Session geladen!)
- Nur kuratierte, dauerhafte Fakten (Entscheidungen, Präferenzen, Projekte)
- Tagesnotizen gehören in `memory/YYYY-MM-DD.md`, nicht hier
- Wird nur in privaten Sessions geladen — nie in Gruppen
- Regelmäßig aufräumen: veraltete Einträge entfernen
```markdown
# Langzeit-Gedächtnis
## User-Präferenzen
- Bevorzugt kurze Antworten mit Code-Beispielen
- Nutzt nala statt apt
- Blog: alexle135.de
## Aktive Projekte
- OpenClaw-Setup auf Contabo VPS
- FISI-Prüfungsvorbereitung
## Wichtige Entscheidungen
- 2026-02-15: Docker-Setup statt npm direkt auf Server
- 2026-02-20: Telegram als Haupt-Channel gewählt
```
---
## BOOTSTRAP.md — Template
```markdown
# Einmal-Setup
Führe folgende Schritte bei deiner ersten Aktivierung aus:
1. Begrüße den User mit Namen
2. Prüfe ob alle Workspace-Dateien vorhanden sind
3. Teste Memory-Schreiben: Schreibe Test-Eintrag in memory/ und lösche ihn
4. Bestätige erfolgreiche Einrichtung
Nach Abschluss wird diese Datei automatisch gelöscht.
```
---
## Git-Backup des Workspace
```bash
cd ~/.openclaw/workspace
git init
git add AGENTS.md SOUL.md TOOLS.md IDENTITY.md USER.md HEARTBEAT.md memory/
git commit -m "Initial workspace setup"
# Privates GitHub-Repo (NIEMALS public!)
git branch -M main
git remote add origin <https-url>
git push -u origin main
```
**Niemals** in ein öffentliches Repo pushen — MEMORY.md enthält persönliche Daten!
```
### references/channels.md
```markdown
# Channels — Messaging-Kanäle einrichten & troubleshooten
## Übersicht
| Kanal | Adapter | Schwierigkeit | Besonderheiten |
|---|---|---|---|
| **Telegram** | grammY | ⭐ Einfach | Streaming, Reactions, Forum-Topics, Empfohlen |
| **WhatsApp** | Baileys | ⭐⭐ Mittel | QR-Pairing, selfChatMode, globale dmPolicy |
| **Discord** | discord.js | ⭐⭐ Mittel | Message Content Intent nötig |
| **Slack** | Bolt | ⭐⭐ Mittel | Socket Mode oder Events API |
| **Signal** | signal-cli | ⭐⭐⭐ Schwer | Java-Dependency, CLI-basiert |
| **iMessage** | BlueBubbles | ⭐⭐⭐ Schwer | Braucht Mac mit Messages-Login |
| **Teams** | Extension | ⭐⭐⭐ Schwer | Entra ID App-Registration |
| **Google Chat** | Chat API | ⭐⭐ Mittel | Google Cloud Projekt nötig |
| **Matrix** | Extension | ⭐⭐ Mittel | Homeserver + Access-Token |
| **WebChat** | Built-in | ⭐ Einfach | Im Dashboard integriert |
---
## Telegram — Vollständige Anleitung
### 1. Bot erstellen
1. `@BotFather` öffnen → `/newbot`
2. Name + Username (muss auf `bot` enden)
3. **Token sicher kopieren** (kein trailing Space!)
4. BotFather-Einstellungen:
```
/setdescription → Kurzbeschreibung
/setabouttext → About-Text
/setuserpic → Profilbild
/setcommands → start, new, status, help
/setprivacy → Disable (für Gruppen ohne @mention)
/setjoingroups → Enable
```
### 2. Minimal-Config
```json5
{
channels: {
telegram: {
enabled: true,
botToken: "123456789:AAH...",
dmPolicy: "pairing", // Default: Pairing-Flow
groups: { "*": { requireMention: true } },
},
},
}
```
Env-Fallback: `TELEGRAM_BOT_TOKEN=...` (nur für Default-Account).
Telegram nutzt NICHT `openclaw channels login telegram`!
### 3. Vollständige Config (alle Felder)
```json5
{
channels: {
telegram: {
enabled: true,
botToken: "123:abc",
dmPolicy: "allowlist", // "pairing" | "allowlist" | "open" | "disabled"
allowFrom: [7403482253], // Numerische User-IDs! NICHT @username
groupPolicy: "allowlist", // "allowlist" | "open" | "disabled"
groupAllowFrom: [7403482253], // Separat von allowFrom (seit 2026.2.25)
// Streaming
streaming: "partial", // "off" | "partial" | "block" | "progress"
// Nachrichten-Formatierung
textChunkLimit: 4000, // Telegram-Limit (max 4096)
chunkMode: "newline", // "newline" = Absatz-Grenzen bevorzugen
// Media
mediaMaxMb: 50, // Default: 5 MB — erhöhen!
// Timeouts & Retries
timeoutSeconds: 30, // Telegram API Timeout
retry: { maxRetries: 3 }, // Outbound-API-Retries
// History
historyLimit: 50, // Gruppen-Context-History (0 = aus)
dmHistoryLimit: 100, // DM-History
// Reactions
// ackReaction: "👀", // Bestätigungs-Emoji beim Verarbeiten
// "" = deaktiviert
// Webhook (optional, statt Long-Polling)
// webhookUrl: "https://yourdomain.com/telegram-webhook",
// webhookSecret: "<secret>",
// webhookPort: 8787, // Default, lokal
// webhookHost: "0.0.0.0", // Nur wenn externer Ingress nötig
// Sonstiges
// linkPreview: false, // Link-Vorschau deaktivieren
// proxy: "http://proxy:8080", // IPv6-Workaround
// configWrites: true, // Channel kann Config schreiben (Default)
},
},
}
```
### 4. Pairing-Workflow
```bash
# Gateway starten
openclaw gateway start
# Bot anschreiben → Pairing-Code erhalten
# Format: "Your Telegram user id: 123456789 Pairing code: ABCD1234"
# Genehmigen:
openclaw pairing approve telegram ABCD1234
# ODER mit User-ID:
openclaw pairing approve telegram:123456789 ABCD1234
# Code verfällt nach 1 Stunde!
```
Danach: Auf `allowlist` wechseln und User-ID in `allowFrom` eintragen.
### 5. User-ID herausfinden
```bash
# Methode 1: Logs lesen
openclaw logs --follow
# → "from.id" in Log-Ausgabe
# Methode 2: Updates API
curl "https://api.telegram.org/bot<TOKEN>/getUpdates" | jq '.result[-1].message.from.id'
# Methode 3: @userinfobot oder @getidsbot anschreiben
```
### 6. Gruppen einrichten
**Privacy Mode** (WICHTIG):
| Privacy Mode | Bot sieht in Gruppen |
|---|---|
| Enabled (Default) | Nur /commands und @mentions |
| Disabled | Alle Nachrichten |
| Bot ist Admin | Alle Nachrichten (unabhängig) |
```
@BotFather → /setprivacy → Disable
# DANN: Bot aus Gruppe entfernen + neu hinzufügen!
```
**Gruppen-Config**:
```json5
{
channels: {
telegram: {
groups: {
"*": { requireMention: true }, // Alle Gruppen: nur @mention
"-1001234567890": { // Spezifische Gruppe
requireMention: false,
groupPolicy: "open", // Jeder in dieser Gruppe
allowFrom: [7403482253],
},
},
},
},
}
```
**Gruppen-ID finden**:
- Nachricht in Gruppe senden → `openclaw logs --follow` → Chat-ID ablesen
- Reguläre Gruppe: `-123456789`
- Supergruppe: `-1001234567890` (100-Prefix nach dem Minus!)
- **ID ändert sich bei Upgrade** auf Supergruppe! → Neues Pairing nötig
**Forum-Gruppen (Topics)**:
- Jedes Topic wird isoliert mit Thread-ID
- Per-Topic-Config-Overrides möglich
- General-Topic = `:topic:1`
### 7. Gruppen-Auth (seit 2026.2.25)
- `groupAllowFrom` ist separat von `allowFrom`
- Gruppen-Auth erbt NICHT DM-Pairing-Approvals
- Commands brauchen Auth auch bei `groupPolicy: "open"`
### 8. Streaming-Modi
| Modus | Verhalten |
|---|---|
| `off` | Keine Vorschau |
| `partial` | Nachricht wird progressiv editiert |
| `block` | Chunked als komplette Blöcke |
| `progress` | = `partial` (Kompatibilität) |
Reasoning-Stream: `/reasoning stream` → Reasoning in Live-Preview, finale Antwort ohne.
### 9. Long-Polling vs. Webhook
| | Long-Polling (Default) | Webhook |
|---|---|---|
| Setup | Kein public URL nötig | HTTPS-Endpoint nötig |
| NAT/Firewall | Funktioniert überall | Braucht offenen Port |
| Latenz | Etwas höher | Niedriger |
| Config | Keine | webhookUrl + webhookSecret |
| Empfehlung | ✅ Für die meisten | Produktion mit Tailscale |
### 10. Telegram Troubleshooting
| Problem | Ursache | Lösung |
|---|---|---|
| 401 Unauthorized | Token falsch/abgelaufen | BotFather → neuen Token → Config → restart |
| Token mit Space kopiert | Trailing Space | Token trimmen, neu einfügen |
| Bot antwortet nicht | User nicht autorisiert | User-ID zu `allowFrom` (als Zahl!) |
| `@username` statt User-ID | Falsches Format | Numerische ID nutzen, nicht @handle |
| Bot schweigt in Gruppen | Privacy Mode enabled | `/setprivacy` Disable → Bot re-adden |
| "plugin not found: telegram" | Falsche Config-Stelle | In `channels.telegram`, NICHT `plugins.entries` |
| Pairing-Code läuft ab | 1h Timeout | Erneut anschreiben → neuer Code |
| Gruppen-ID geändert | Upgrade auf Supergruppe | Neue -100-ID in Config/Pairing |
| `TypeError: fetch failed` | IPv6-Problem auf VPS | IPv4 erzwingen (s.u.) |
| Nachrichten abgeschnitten | 4000-Zeichen-Limit | `chunkMode: "newline"` |
| Bot nach Update tot | Alter Prozess läuft noch | `ps aux \| grep openclaw` → killen |
| Migration Clawdbot→OpenClaw | Alte Config/Prozesse | `cp -r ~/.clawdbot/* ~/.openclaw/` + alte stoppen |
| "access not configured" | Pairing OK, aber nicht autorisiert | `dmPolicy: "allowlist"` + `allowFrom` setzen |
**IPv6-Problem fix**:
```bash
# Prüfen:
dig +short api.telegram.org A
dig +short api.telegram.org AAAA
# Fix: IPv4 erzwingen via /etc/hosts
echo "$(dig +short api.telegram.org A | head -1) api.telegram.org" | sudo tee -a /etc/hosts
# Oder: proxy in Config setzen
```
---
## WhatsApp — Vollständige Anleitung
### Config
```json5
{
channels: {
whatsapp: {
enabled: true,
dmPolicy: "allowlist",
selfChatMode: true,
allowFrom: ["+4915568920209"], // E.164 MIT + !
groupPolicy: "allowlist",
debounceMs: 0, // 0 = sofort
mediaMaxMb: 50,
},
},
}
```
### QR-Code scannen
```bash
openclaw gateway start
# QR erscheint in Terminal oder Dashboard → Channels-Seite
# WhatsApp → Verknüpfte Geräte → QR scannen
```
### WhatsApp-Eigenheiten
- **dmPolicy ist GLOBAL** für den ganzen WhatsApp-Account (nicht per-Agent!)
- **selfChatMode**: Nachrichten an sich selbst = Bot-Befehle
- **Max 4 verknüpfte Geräte** (WhatsApp-Limit)
- **Baileys** = Reverse-Engineered, kein offizielles API → kann brechen
### WhatsApp Troubleshooting
| Problem | Lösung |
|---|---|
| QR erscheint nicht | Dashboard → Channels nutzen |
| "Connection closed" nach Scan | Gateway restart → erneut scannen |
| Bot antwortet nicht | `allowFrom` mit +Ländercode prüfen |
| Nachrichten verzögert | `debounceMs: 0` |
| Media nicht verarbeitet | `mediaMaxMb` erhöhen |
| Nach einigen Tagen getrennt | WhatsApp-App → Verknüpfte Geräte prüfen |
---
## Discord
```json5
{
channels: {
discord: {
enabled: true,
botToken: "<discord-bot-token>",
dmPolicy: "allowlist",
},
},
}
```
**PFLICHT**: Discord Developer Portal → Bot → Privileged Gateway Intents → **Message Content Intent** aktivieren!
---
## Slack
```json5
{
channels: {
slack: {
enabled: true,
appToken: "xapp-...", // Socket Mode Token
botToken: "xoxb-...", // Bot OAuth Token
},
},
}
```
---
## Signal
```json5
{
channels: {
signal: { enabled: true },
// signal-cli muss installiert + registriert sein
// Java 17+ nötig
},
}
```
---
## iMessage (BlueBubbles)
```json5
{
channels: {
imessage: {
enabled: true,
adapter: "bluebubbles",
host: "http://<mac-tailscale-ip>:1234",
password: "<bluebubbles-password>",
},
},
}
```
Mac mit Messages eingeloggt + BlueBubbles-Server nötig.
---
## CLI: Channels verwalten
```bash
openclaw channels status # Alle Channels
openclaw channels status --probe # Mit Live-Check
openclaw channels restart telegram
openclaw channels restart whatsapp
# Nachricht senden
openclaw message send --channel telegram --target 7403482253 --message "Test"
openclaw message send --channel telegram --target @username --message "Test"
openclaw message send --channel whatsapp --target "+4915568920209" --message "Test"
# Logs
openclaw logs --follow --channel telegram
```
---
## Allgemeine Regeln
1. **dmPolicy immer `allowlist`** in Produktion
2. **allowFrom korrekt**: Telegram = Zahl, WhatsApp = E.164 String
3. **mediaMaxMb erhöhen** — Default ist oft nur 5 MB
4. **Nach Config-Änderung**: `openclaw channels restart <channel>`
5. **Streaming spart keine Tokens** — nur UX
6. **plugins.entries** ≠ **channels** — Channel-Config gehört in `channels`!
```
### references/memory-system.md
```markdown
# Memory-System — Deep Dive
## Architektur-Überblick
OpenClaw nutzt ein dateibasiertes Markdown-Memory-System mit optionaler semantischer Suche.
Kernprinzip: **Dateien sind die Quelle der Wahrheit** — der Agent behält nur, was auf Disk geschrieben wird.
```
Workspace/
├── MEMORY.md # Langzeit (kuratiert, ~100 Zeilen, nur private Sessions)
└── memory/
├── 2026-02-15.md # Tages-Log (append-only)
├── 2026-02-16.md
└── ...
```
### Zwei Ebenen
1. **MEMORY.md** — Kuratierte, dauerhafte Fakten (Entscheidungen, Präferenzen). In jede private Session geladen.
2. **memory/YYYY-MM-DD.md** — Tagesnotizen, Running-Log. Über memorySearch abrufbar.
---
## Memory Flush (automatisch vor Compaction)
Wenn eine Session sich der Context-Window-Grenze nähert, triggert OpenClaw einen stillen Turn:
- Agent wird aufgefordert, wichtige Infos in `memory/YYYY-MM-DD.md` zu schreiben
- Standard-Antwort: `NO_REPLY` (User sieht nichts)
### Konfiguration
```json5
agents: {
defaults: {
compaction: {
reserveTokensFloor: 20000,
memoryFlush: {
enabled: true, // Default: true
softThresholdTokens: 4000, // Wann der Flush triggert
systemPrompt: "Session nearing compaction. Store durable memories now.",
prompt: "Write any lasting notes to memory/YYYY-MM-DD.md; reply with NO_REPLY if nothing to store.",
},
},
},
},
```
### Flush-Details
- Triggert wenn: `tokenEstimate > contextWindow - reserveTokensFloor - softThresholdTokens`
- Ein Flush pro Compaction-Zyklus (in sessions.json getrackt)
- Workspace muss schreibbar sein (`workspaceAccess: "ro"` oder `"none"` → Flush übersprungen)
---
## Session Compaction
Wenn das Context-Window voll ist, kompaktiert OpenClaw ältere Nachrichten:
- Zusammenfassung/Truncation älterer Messages
- **Risiko**: Wichtige Details gehen verloren wenn nicht in Memory geschrieben
- **memoryFlush** rettet Infos vor der Compaction
### Compaction-Modi
```json5
compaction: {
mode: "safeguard", // "safeguard" = Flush + Compaction
// "full" = Aggressivere Compaction
// "off" = Keine Compaction (Risiko: Token-Limit-Fehler)
}
```
---
## Semantic Memory Search (memorySearch)
Baut einen kleinen Vektor-Index über MEMORY.md und memory/*.md für semantische Abfragen.
### Konfiguration
```json5
agents: {
defaults: {
memorySearch: {
enabled: true, // Default: true
provider: null, // null = Auto-Detect
// Auto-Detect-Reihenfolge:
// 1. local (wenn modelPath existiert)
// 2. openai (wenn Key vorhanden)
// 3. gemini (wenn Key vorhanden)
// 4. disabled
local: {
modelPath: null, // Pfad zu GGUF-Embedding-Modell
},
extraPaths: [ // Zusätzliche Pfade indexieren
"../team-docs",
"/srv/shared-notes/overview.md",
],
},
},
},
```
### Funktionsweise
- Dateien werden in ~400-Token-Chunks mit 80-Token-Overlap aufgeteilt
- Vektor-Embeddings in SQLite gespeichert (sqlite-vec für Beschleunigung)
- Datei-Änderungen werden automatisch erkannt (File Watcher, debounced)
- **Erster Aufruf kann langsam sein**: QMD lädt ggf. GGUF-Modelle herunter
### Temporal Decay (Zeitverfall)
Memory-Ergebnisse werden nach Aktualität gewichtet:
| Alter | Decay-Faktor |
|---|---|
| Heute | 1.00 |
| 7 Tage | ~0.85 |
| 30 Tage | ~0.50 |
| 148 Tage | ~0.03 |
Score = `semantic_score × decay_factor`
→ Neuere Erinnerungen werden bevorzugt, auch wenn ältere semantisch besser passen.
### Datum-Quellen
- `memory/YYYY-MM-DD.md` → Datum aus Dateiname
- Session-Transkripte → Fallback auf mtime
---
## Session-Transkript-Indexierung
OpenClaw kann vergangene Konversationen automatisch speichern und indexieren:
- Session wird als timestamped Datei gespeichert (Slug per LLM generiert)
- Transkripte werden indexiert und über memorySearch durchsuchbar
- Erlaubt: "Was haben wir letzte Woche zu Thema X besprochen?"
---
## Bekannte Limitierungen
1. **Kein Relationship-Reasoning**: Memory findet ähnlichen Text, versteht aber keine Beziehungen
(z.B. "Alice managt das Auth-Team" + "Wer kümmert sich um Permissions?" → keine automatische Verbindung)
2. **Cross-Projekt-Noise**: Bei mehreren Projekten können irrelevante Ergebnisse auftauchen
3. **Compaction-Verlust**: Was nicht in Memory geschrieben ist, geht bei Compaction verloren
4. **MEMORY.md im Context**: Wird in den Context geladen → kann selbst kompaktiert werden bei langen Sessions
---
## Verbesserungen / Community-Plugins
### Cognee Knowledge Graph
- Fügt eine Graph-Datenbank über Memory-Dateien
- Versteht Beziehungen zwischen Fakten
- `pip install cognee-mcp` + Config in openclaw.json
### Mem0 Persistent Memory
- Speichert Memory extern, außerhalb des Context-Windows
- Compaction kann Mem0-Memories nicht zerstören
- Long-Term + Short-Term Memory Scopes
- Config: `skills.entries["openclaw-mem0"].enabled: true`
---
## Tipps für effektives Memory
1. **Explizit schreiben lassen**: "Merke dir, dass ich Docker bevorzuge" → Agent schreibt in MEMORY.md/USER.md
2. **Regelmäßig aufräumen**: Veraltete memory/*.md Dateien archivieren
3. **MEMORY.md klein halten**: Max ~100 Zeilen, nur Dauerhaftes
4. **Präferenzen in USER.md**: Nicht in Memory, sondern dort wo sie jede Session geladen werden
5. **Memory-Review im Heartbeat**: HEARTBEAT.md-Aufgabe "Memory konsolidieren" hinzufügen
```
### references/docker-setup.md
```markdown
# Docker-Deployment — Deep Dive
## Wann Docker?
| Szenario | Docker? | Begründung |
|---|---|---|
| VPS/Server (24/7) | ✅ Ja | Isolation, Reproduzierbarkeit |
| macOS lokal | ❌ Nein | VM-Overhead, npm direkt schneller |
| Sandbox für Tools | ✅ Ja | Gateway lokal, Tools in Container |
| Erstmalig testen | ✅ Ja | Sicher, leicht entfernbar |
---
## Offizielles Docker-Setup
```bash
git clone https://github.com/openclaw/openclaw.git
cd openclaw
bash docker-setup.sh
```
### docker-setup.sh macht:
1. Baut Docker-Image (`openclaw:local`)
2. Startet Onboarding-Wizard (interaktiv)
3. Setzt Control-UI CORS-Origins
4. Gibt Befehle für Channel-Setup aus
### Wizard-Empfehlungen im Docker:
- Gateway bind: **lan** (innerhalb Docker-Netzwerk)
- Gateway auth: **token**
- Tailscale: **Off**
- Gateway daemon: **No** (Docker managed den Lifecycle)
---
## Docker Compose
```yaml
services:
openclaw-gateway:
image: openclaw:local
restart: unless-stopped
ports:
- "18789:18789"
volumes:
- ~/.openclaw:/home/node/.openclaw
- ~/openclaw/workspace:/home/node/.openclaw/workspace
# Optional: User-Mapping
# user: "1000:1000"
openclaw-cli:
image: openclaw:local
volumes:
- ~/.openclaw:/home/node/.openclaw
- ~/openclaw/workspace:/home/node/.openclaw/workspace
profiles: ["cli"]
entrypoint: ["openclaw"]
```
### CLI via Docker Compose
```bash
docker compose run --rm openclaw-cli doctor
docker compose run --rm openclaw-cli channels add --channel telegram --token <TOKEN>
docker compose run --rm openclaw-cli channels login # WhatsApp QR
docker compose run --rm openclaw-cli dashboard --no-open
```
---
## Container-Image Details
Das Default-Image ist **security-first** (non-root `node` User):
- Kein Chromium/Playwright vorinstalliert
- Kein sudo
- Minimale Angriffsfläche
### Playwright/Browser installieren
```bash
docker compose exec openclaw-gateway \
node /app/node_modules/playwright-core/cli.js install chromium
```
### Extra-Pakete installieren
```bash
# Option 1: Zur Buildzeit (persistiert)
export OPENCLAW_DOCKER_APT_PACKAGES="ripgrep jq"
bash docker-setup.sh # Rebuild
# Option 2: Zur Laufzeit (geht bei Container-Neustart verloren)
docker compose exec -u root openclaw-gateway bash
apt-get update && apt-get install -y ripgrep
```
---
## Permissions-Probleme (häufig!)
```bash
# Option 1 (empfohlen): Ownership auf UID 1000
sudo chown -R 1000:$(id -g) ~/.openclaw
sudo chmod -R u+rwX,g+rwX,o-rwx ~/.openclaw
# Option 2: Gruppe beschreibbar
chmod -R 775 ~/.openclaw
# Option 3 (LETZTER AUSWEG): World-Writable
chmod -R 777 ~/.openclaw
```
---
## Docker + Ollama (lokale Modelle)
```json5
models: {
providers: {
ollama: {
// macOS Docker Desktop:
baseUrl: "http://host.docker.internal:11434",
// Linux (Docker-Bridge-IP):
baseUrl: "http://172.17.0.1:11434",
apiKey: "ollama-local",
api: "openai-completions",
},
},
},
```
---
## Agent-Sandbox (Gateway lokal, Tools in Docker)
Separate Sandbox NUR für Tool-Ausführung (nicht den ganzen Gateway):
```json5
tools: {
exec: {
host: "sandbox", // Tools in Docker-Container ausführen
},
},
docker: {
network: "none", // Kein Netzwerk in Sandbox
},
```
- Container wird automatisch erstellt/recycled
- `setupCommand` ändern → Container wird neu erstellt (~5min Cooldown)
- `network: "none"` = kein Internet für Tools (sicherste Option)
---
## Troubleshooting Docker
| Problem | Lösung |
|---|---|
| Build OOM-Killed (exit 137) | Mindestens 2 GB RAM |
| Workspace nicht sichtbar | Volume-Mount prüfen in docker-compose.yml |
| "Cannot connect to Docker daemon" | `sudo systemctl start docker` |
| Slow auf macOS | VM-Overhead — npm direkt nutzen |
| Permission denied | Ownership/Permissions oben prüfen |
| Container startet nicht nach Config-Änderung | `docker compose run --rm openclaw-cli doctor` |
```
### references/security-hardening.md
```markdown
# Security-Hardening — OpenClaw absichern
## Threat Model
OpenClaw hat **volle Kontrolle über den Rechner** — kann Dateien erstellen/löschen,
Software installieren, Skripte ausführen, Internet-Dienste kontaktieren.
Deshalb: Isolation und Least-Privilege sind Pflicht.
---
## Checkliste (Minimum-Sicherheit)
```bash
# 1. Gateway nur lokal binden
openclaw config set gateway.bind loopback
# 2. DM-Policy auf Allowlist
openclaw config set dmPolicy.mode allowlist
# Eigene User-IDs eintragen!
# 3. Token rotieren (64+ Zeichen)
openclaw token:rotate --force --length 64
# 4. Credentials schützen
chmod 600 ~/.openclaw/credentials/*
# 5. Doctor prüft Security-Config
openclaw doctor
openclaw doctor --run doctor # DM-Policy-Check
openclaw security audit --deep # Tiefes Audit
```
---
## Gateway-Sicherheit
| Setting | Sicher | Gefährlich |
|---|---|---|
| `gateway.bind` | `loopback` | `lan`, `0.0.0.0` |
| `gateway.auth.mode` | `token` | `none` |
| `dmPolicy.mode` | `allowlist` | `open` |
| `tools.exec.host` | `sandbox` | `gateway` |
| `tools.exec.security` | `full` | `relaxed` |
### Remote-Zugriff (wenn nötig)
- **Tailscale** (empfohlen): `gateway.mode: "tailscale"`, `gateway.bind: "tailscale"`
- **SSH-Tunnel**: `ssh -L 18789:127.0.0.1:18789 user@server`
- **NIEMALS** Port 18789 direkt ins Internet exponieren!
---
## DM-Policy
```json5
dmPolicy: {
mode: "allowlist", // PFLICHT in Produktion
allowed_ids: [ // Nur deine User-IDs
"+491234567890",
"telegram:123456789",
],
reject_action: "silent_drop", // Abgelehnte Nachrichten still verwerfen
log_rejections: true, // Für Audit-Log
}
```
**Bei `open`**: Jeder kann dem Bot schreiben und Befehle ausführen!
---
## Skill-Sicherheit
Skills sind die größte Angriffsfläche:
- **26% der Community-Skills** enthalten laut Cisco mindestens eine Schwachstelle
- Skills können Prompt-Injections, Tool-Poisoning, versteckte Malware enthalten
### Vor Installation:
1. Quellcode auf GitHub/ClawHub reviewen
2. "Hide Suspicious" auf ClawHub aktivieren
3. VirusTotal-Report auf der ClawHub-Seite prüfen
4. Code in Claude/GPT einfügen und nach Risiken fragen
5. Unbekannte Skills erst in Sandbox testen
### Skill-Sandbox:
```json5
tools: {
exec: {
host: "sandbox", // Skills in Docker-Sandbox ausführen
},
}
```
---
## API-Key-Management
```bash
# Keys NIE in Workspace-Dateien speichern!
# Keys NIE in öffentliche Repos pushen!
# Secrets-Check:
grep -r "sk-" ~/.openclaw/
grep -r "ANTHROPIC_API_KEY" ~/.openclaw/workspace/
# → Sollte nichts finden
# API-Spending-Limits beim Provider setzen!
# Heartbeat alle 30min kann $0.50-2.00/Tag kosten
```
### Für Fortgeschrittene: Doppler Secrets-Manager
- API-Keys nicht in Config hardcoden
- Über Environment-Variables injizieren
- `openclaw config set` für Key-Referenzen nutzen
---
## Betriebssystem-Härtung
```bash
# Eigenen User für OpenClaw anlegen
sudo adduser --system --home /home/openclaw openclaw
# Firewall (ufw)
sudo ufw default deny incoming
sudo ufw allow ssh
# Port 18789 NICHT freigeben (nur loopback!)
# Nicht als root betreiben!
# ssh openclaw@server, dann openclaw-Befehle
```
---
## Sandbox-Konfiguration
```json5
docker: {
network: "none", // Kein Netzwerk in Sandbox (sicherste Option)
// Für Skills die Internet brauchen:
// network: "bridge",
},
tools: {
exec: {
host: "sandbox", // Tools in Docker-Container ausführen
ask: "on", // Bestätigung vor jeder Tool-Ausführung
security: "full",
},
},
```
### Sandbox-Limitierungen
- Default: kein Netzwerk (`network: "none"`)
- `setupCommand` braucht `network != "none"` und `user: "0:0"` für apt-get
- OpenClaw erstellt Container neu wenn sich `setupCommand` oder Docker-Config ändert
---
## Audit & Monitoring
```bash
# Regelmäßiger Security-Check
openclaw security audit --deep
# Logs überwachen
journalctl --user -u openclaw-gateway -f
# Rejected DMs prüfen (wenn log_rejections: true)
grep "reject" /tmp/openclaw-gateway.log
# Session-Kosten überwachen
# /status im Chat → zeigt Tokens und Kosten
```
---
## Empfohlene Architektur für VPS
```
VPS (Contabo/Hetzner/DO)
├── Docker-Container: openclaw-gateway
│ ├── Non-root user (node)
│ ├── Gateway bind: loopback
│ └── Sandbox für Tools
├── ufw: nur SSH erlaubt
├── Tailscale: für Remote-Dashboard-Zugriff
└── Separater User: kein Zugriff auf Prod-Daten
```
```
### references/skills-guide.md
```markdown
# Skills — Entwicklung, Installation & Sicherheit
## Skill-Typen
| Typ | Pfad | Beschreibung |
|---|---|---|
| Bundled | Im npm-Paket | Mitgelieferte Skills |
| Managed | `~/.openclaw/skills/` | Via ClawHub installiert |
| Workspace | `<workspace>/skills/` | Manuell erstellt, pro Agent |
---
## Skills installieren
```bash
# ClawHub durchsuchen
clawhub search "memory"
clawhub search "calendar"
# Installieren
clawhub install <skill-name>
# Updaten
clawhub update <skill-name>
clawhub update --all
# Nach Installation: Skills neu laden
openclaw skills reload
# ODER Gateway neu starten (Skills werden erst in neuer Session aktiv!)
openclaw gateway restart
# Installierte Skills anzeigen
openclaw skills list
```
### Skills in openclaw.json konfigurieren
```json5
skills: {
install: {
nodeManager: "npm", // "npm" | "pnpm"
},
entries: {
"skill-name": {
enabled: true,
apiKey: "LLM_API_KEY", // Optional: API-Key für diesen Skill
env: { // Optional: Environment-Variables
"TOOL_TOKEN": "xxx",
"SERVICE_API_KEY": "yyy",
},
},
},
},
```
---
## Eigene Skills erstellen
### SKILL.md-Format
```markdown
---
name: mein-skill
description: >
Beschreibung was der Skill tut und wann er getriggert werden soll.
Beispiel-Trigger-Phrasen hier auflisten.
---
# Mein Skill
## Anweisungen
Hier stehen die Anweisungen für den Agent...
## Beispiele
Input: "Mach X"
Output: Y
```
### Verzeichnis-Struktur
```
mein-skill/
├── SKILL.md # Pflicht: Anweisungen
├── scripts/ # Optional: Ausführbare Skripte
├── references/ # Optional: Referenz-Dokumente
└── assets/ # Optional: Templates, Icons
```
### Workspace-Skills erstellen
```bash
mkdir -p ~/.openclaw/workspace/skills/mein-skill
# SKILL.md dort anlegen
# Skills neu laden:
openclaw skills reload
```
### Skills teilen
```bash
# Auf ClawHub veröffentlichen (nach Review!)
# Oder als Git-Repo teilen
```
---
## Skill-Sicherheit (KRITISCH!)
ClawHub hostet 5700+ Skills (Stand 02/2026). Nicht alle sind sicher.
### Risiken
- Prompt-Injections in SKILL.md
- Tool-Poisoning (Skill nutzt Tools für böswillige Zwecke)
- Versteckte Malware-Payloads in scripts/
- Unsichere Datenverarbeitung
### Schutzmaßnahmen
1. **Quellcode reviewen** vor Installation
2. **ClawHub "Hide Suspicious"** aktivieren
3. **VirusTotal-Report** auf ClawHub-Seite prüfen
4. **Code in Claude einfügen** und nach Risiken fragen lassen
5. **Sandbox nutzen**: `tools.exec.host: "sandbox"`
6. **Nur verifizierte Skills** von bekannten Autoren installieren
### Nützliche Community-Skills (geprüft)
- `memory-complete` — Vollständiges Memory-Protokoll mit Auto-Capture
- `agent-builder` — Agent-Workspace-Generator
- `soul-md` — Persona/Identity-Management
- `context-anchor` — Recovery nach Context-Compaction
- `claw-roam` — Workspace-Sync zwischen Maschinen
---
## Skill-Troubleshooting
```bash
# Skills nicht sichtbar?
openclaw skills list # Prüfen ob Skill gelistet
ls ~/.openclaw/workspace/skills/ # Workspace-Skills prüfen
ls ~/.openclaw/skills/ # Managed-Skills prüfen
# Skill nicht aktiv nach Installation?
openclaw gateway restart # Skills erst in neuer Session!
# Nur 1 von 6 Skills registriert?
# → SKILL.md-Format prüfen: name + description im YAML-Frontmatter Pflicht
# → Kein Syntax-Fehler im YAML (Doppelpunkt in description escapen!)
```
```
### references/multi-agent.md
```markdown
# Multi-Agent-Routing
## Konzept
Ein Gateway kann mehrere Agents hosten, jeder mit eigenem:
- **Workspace** (SOUL.md, AGENTS.md, Memory)
- **agentDir** (Auth-Profile, Sessions)
- **Session-Store** (`~/.openclaw/agents/<agentId>/sessions/`)
### Begriffe
| Begriff | Bedeutung |
|---|---|
| `agentId` | Ein "Gehirn" (Workspace, Auth, Sessions) |
| `accountId` | Ein Channel-Account (z.B. WhatsApp-Nummer "personal" vs "biz") |
| `binding` | Routing-Regel: `(channel, accountId, peer)` → `agentId` |
---
## Konfiguration
```json5
{
agents: {
defaults: {
workspace: "~/.openclaw/workspace",
},
list: [
{
id: "alex",
workspace: "~/.openclaw/workspace-alex",
},
{
id: "mia",
workspace: "~/.openclaw/workspace-mia",
},
],
},
bindings: [
{
agentId: "alex",
match: {
channel: "whatsapp",
peer: { kind: "direct", id: "+491111111111" },
},
},
{
agentId: "mia",
match: {
channel: "whatsapp",
peer: { kind: "direct", id: "+492222222222" },
},
},
// Discord: nach Guild-ID routen
// {
// agentId: "work",
// match: {
// channel: "discord",
// guildId: "123456789",
// },
// },
],
channels: {
whatsapp: {
dmPolicy: "allowlist",
allowFrom: ["+491111111111", "+492222222222"],
},
},
}
```
---
## Routing-Logik
Bindings sind deterministisch, "most-specific wins":
1. Binding mit allen Match-Feldern (channel + accountId + peer + guildId)
2. Binding mit weniger spezifischen Feldern
3. Fallback: Default-Agent (`agents.list[].default: true`, sonst erster Eintrag)
Bei gleicher Spezifität: Erste Binding in Config-Reihenfolge gewinnt.
Mehrere Match-Felder = AND-Semantik (alle müssen zutreffen).
---
## Wichtige Regeln
1. **Nie agentDir zwischen Agents teilen** → Auth/Session-Kollisionen
2. **Auth-Profile sind per-Agent** — Main-Agent-Credentials werden nicht automatisch geteilt
3. **Skills**: Per-Agent via Workspace `skills/`, shared via `~/.openclaw/skills/`
4. **WhatsApp dmPolicy**: Global pro Account, nicht pro Agent!
5. **Discord/Telegram**: Pro Agent ein eigener Bot nötig
6. **Binding-Upgrade**: Wenn du eine channel-only Binding und dann eine mit accountId hinzufügst,
wird die bestehende automatisch auf account-scoped upgraded (kein Duplikat)
---
## Setup für Multi-Agent
```bash
# Workspaces erstellen
mkdir -p ~/.openclaw/workspace-alex
mkdir -p ~/.openclaw/workspace-mia
# Workspace-Dateien initialisieren
openclaw setup --workspace ~/.openclaw/workspace-alex
openclaw setup --workspace ~/.openclaw/workspace-mia
# Dann SOUL.md, AGENTS.md etc. in jedem Workspace individuell anpassen
```
```
### references/cli-reference.md
```markdown
# OpenClaw CLI-Referenz (Vollständig)
> Stand: Februar 2026. OpenClaw ändert sich häufig — bei unbekannten Flags `openclaw <command> --help` nutzen.
## Inhaltsverzeichnis
1. [Gateway](#gateway)
2. [Doctor & Diagnose](#doctor--diagnose)
3. [Channels](#channels)
4. [Nodes](#nodes)
5. [Models](#models)
6. [Skills & ClawHub](#skills--clawhub)
7. [Config](#config)
8. [Sessions](#sessions)
9. [Memory](#memory)
10. [Pairing](#pairing)
11. [Security](#security)
12. [Setup & Onboarding](#setup--onboarding)
13. [Update & Versioning](#update--versioning)
14. [Dashboard & TUI](#dashboard--tui)
---
## Gateway
```bash
openclaw gateway start # Gateway starten
openclaw gateway stop # Gateway stoppen
openclaw gateway restart # Neustart (NACH Config-Änderung!)
openclaw gateway status # Status prüfen
openclaw gateway install # Als systemd user-service installieren
openclaw gateway uninstall # Service entfernen
openclaw gateway log # Logs anzeigen
# Äquivalent: journalctl --user -u openclaw-gateway -f
# Fallback-Log: tail -n 120 /tmp/openclaw-gateway.log
```
### systemd User-Service manuell
```bash
# WICHTIG: Immer als openclaw-User, NICHT als root!
ssh openclaw@<server-ip>
openclaw gateway install
systemctl --user start openclaw-gateway
systemctl --user enable openclaw-gateway
# Status: systemctl --user status openclaw-gateway
# Logs: journalctl --user -u openclaw-gateway -f --no-pager
```
### Gateway-Port prüfen
```bash
ss -ltnp | grep 18789
# oder:
lsof -i :18789
```
---
## Doctor & Diagnose
```bash
openclaw doctor # Vollständiger Gesundheitscheck
openclaw doctor --fix # Auto-Fix versuchen
openclaw doctor --run doctor # DM-Policy prüfen
openclaw status # Kompakter Status (Model, Tokens, Cost)
```
**GOLDENE REGEL**: `openclaw doctor` VOR und NACH jeder Config-Änderung ausführen.
---
## Channels
```bash
openclaw channels list # Alle Kanäle anzeigen
openclaw channels status --probe # Live-Check aller Kanäle
openclaw channels add # Kanal hinzufügen (interaktiver Wizard)
openclaw channels add --channel telegram --token <BOT_TOKEN>
openclaw channels add --channel discord --token <BOT_TOKEN>
openclaw channels login # WhatsApp QR-Code-Login
openclaw channels remove <name> # Kanal entfernen
openclaw channels restart <name> # Kanal neu starten
```
### Unterstützte Kanäle (Stand 02/2026)
WhatsApp, Telegram, Slack, Discord, Google Chat, Signal,
BlueBubbles (iMessage), iMessage (legacy), Microsoft Teams,
Matrix, Zalo, Zalo Personal, WebChat, LINE, Mattermost
### Chat-Befehle (in WhatsApp/Telegram/Slack etc.)
```
/status — Session-Status (Modell, Tokens, Kosten)
/new — Neue Session starten
/compact — Kontext manuell kompaktieren
```
---
## Nodes
```bash
openclaw nodes list # Alle Nodes anzeigen
openclaw nodes status # Node-Status
openclaw nodes pair <type> # Node pairen (ios/android/mac/pi)
openclaw nodes remove <id> # Node entfernen
```
Node-Typen: iOS, Android, macOS (Menübar-App), Raspberry Pi
---
## Models
```bash
openclaw models list # Verfügbare Modelle anzeigen
openclaw models set <model-id> # Aktives Modell setzen
```
### Model-ID-Format
```
provider/model-name
```
Beispiele:
```
anthropic/claude-sonnet-4-5
anthropic/claude-opus-4-6
openai/gpt-4o
ollama/llama3.2:latest
openrouter/moonshotai/kimi-k2 # Bei / im Model-Name: Provider-Prefix!
```
**WICHTIG**: Wenn die Model-ID selbst `/` enthält (z.B. OpenRouter-Style),
MUSS der Provider-Prefix dabei sein: `openrouter/moonshotai/kimi-k2`
---
## Skills & ClawHub
```bash
openclaw skills list # Installierte Skills anzeigen
openclaw skills reload # Skills neu laden (neue Session nötig!)
clawhub search <query> # ClawHub durchsuchen
clawhub install <skill-name> # Skill installieren
clawhub update <skill-name> # Skill updaten
clawhub update --all # Alle Skills updaten
```
Skills werden erst in einer **neuen Session** aktiv — nach `openclaw skills reload`
oder `openclaw gateway restart`.
### Skill-Verzeichnisse
```
~/.openclaw/skills/ # Managed Skills (clawhub install)
~/.openclaw/workspace/skills/ # Workspace Skills (manuell)
```
---
## Config
```bash
openclaw config list # Alle Config-Werte anzeigen
openclaw config get <key> # Einzelnen Wert lesen
openclaw config set <key> <value> # Wert setzen (live, ohne Neustart)
openclaw config validate # Config validieren (≈ doctor)
```
---
## Sessions
```bash
openclaw sessions list # Aktive Sessions anzeigen
openclaw sessions clean # Alte Sessions aufräumen
```
Session-Speicherort: `~/.openclaw/agents/<agentId>/sessions/<SessionId>.jsonl`
---
## Memory
```bash
openclaw memory flush # Gedächtnis in MEMORY.md schreiben
```
---
## Pairing
```bash
openclaw pairing list # Ausstehende Pairings
openclaw pairing approve telegram <CODE> # Telegram-Pairing bestätigen
openclaw pairing approve whatsapp <CODE> # WhatsApp-Pairing bestätigen
openclaw pairing approve discord <CODE> # Discord-Pairing bestätigen
```
---
## Security
```bash
openclaw token:rotate --force --length 64 # Gateway-Token rotieren
openclaw security audit --deep # Tiefes Sicherheitsaudit
openclaw doctor --run doctor # DM-Policy prüfen
# Exposed-Secrets-Check (manuell):
grep -r "sk-" ~/.openclaw/ # Sollte nichts in Logs finden
grep -r "ANTHROPIC_API_KEY" ~/.openclaw/workspace/
```
---
## Setup & Onboarding
```bash
openclaw onboard # Setup-Wizard erneut ausführen (interaktiv)
openclaw setup # Workspace-Dateien erstellen (AGENTS.md etc.)
openclaw setup --workspace <path> # Fehlende Workspace-Dateien an bestimmtem Pfad erzeugen
```
---
## Update & Versioning
```bash
# Version anzeigen
openclaw --version
# Format: YYYY.M.D-N (CalVer)
# Update (pnpm empfohlen):
pnpm add -g openclaw@latest && pnpm approve-builds -g && openclaw doctor
# Alternative (npm):
npm install -g openclaw@latest && openclaw doctor
# Beta-Channel:
pnpm add -g openclaw@beta && pnpm approve-builds -g
# Release-Tags:
# stable = npm dist-tag "latest" → getaggte Releases (vYYYY.M.D)
# beta = npm dist-tag "beta" → Prerelease (vYYYY.M.D-beta.N)
# dev = main Branch (kein Tag)
```
---
## Dashboard & TUI
```bash
openclaw dashboard # Browser-UI öffnen (http://127.0.0.1:18789)
openclaw dashboard --no-open # URL ausgeben ohne Browser zu öffnen
openclaw tui # Terminal-UI starten
```
Das Dashboard bietet:
- WebChat-Interface
- Session-Debugging
- Config-Verwaltung
- Health-Monitoring
- Token-Eingabe (Settings → Token)
```
### references/nodes-and-remote.md
```markdown
# Nodes & Remote Access — Geräte als Nodes anschließen
## Was ist ein Node?
Ein Node ist ein **Companion-Gerät** (macOS, iOS, Android, Headless-Linux), das sich per WebSocket
mit dem Gateway verbindet und lokale Aktionen ausführt (Kamera, Screen, Canvas, Shell-Befehle).
**Nodes sind KEINE Gateways.** Messaging-Kanäle (Telegram, WhatsApp etc.) laufen auf dem Gateway,
nicht auf Nodes. Nodes sind Peripheriegeräte.
```
┌─────────────────────────────────┐
│ Gateway (VPS/Server) │ ← Messaging, Sessions, Brain
│ ws://127.0.0.1:18789 │
└──────────┬──────────────────────┘
│ WebSocket (Tailscale/LAN)
┌──────┴──────────────────────┐
│ Node: MacBook (macOS App) │ ← Browser-Control, Canvas, Voice Wake
│ Node: iPhone (iOS App) │ ← Kamera, Screen Recording, Canvas
│ Node: Android Phone │ ← Kamera, Screen Recording, SMS
│ Node: Raspberry Pi │ ← system.run, Hardware-Control
│ Node: Headless Linux │ ← system.run, system.which
└─────────────────────────────┘
```
---
## Node-Typen & Fähigkeiten
| Node-Typ | Fähigkeiten | Pairing |
|---|---|---|
| macOS Menübar-App | Voice Wake, PTT, WebChat, Canvas, Browser-Control, Debug | Bonjour/mDNS |
| iOS App | Canvas, Voice Wake, Talk Mode, Kamera, Screen Recording | QR-Code / Deep Link |
| Android App | Canvas, Talk Mode, Kamera, Screen Recording, SMS | QR-Code |
| macOS Node-Mode | system.run, system.notify, Canvas, Kamera | Bonjour/mDNS |
| Headless Node | system.run, system.which (kein UI) | CLI-Pairing |
---
## Szenario: Gateway auf VPS + MacBook als Node
### Voraussetzungen
- Gateway läuft auf VPS (Contabo, Hetzner, etc.)
- Tailscale auf beiden Geräten installiert und eingeloggt
- Beide im selben Tailnet
### Schritt 1: Tailscale auf VPS installieren
```bash
# Auf dem VPS:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
# Tailscale-IP notieren: tailscale ip -4
```
### Schritt 2: Gateway für Tailscale konfigurieren
```json5
// ~/.openclaw/openclaw.json auf dem VPS:
{
gateway: {
bind: "loopback", // Bleibt loopback!
tailscale: {
mode: "serve", // Tailnet-only (empfohlen)
// mode: "funnel", // NUR wenn öffentlich nötig (GEFÄHRLICH!)
resetOnExit: false,
},
auth: {
mode: "token",
token: "<64-zeichen-token>",
allowTailscale: true, // Tailscale-Identity-Auth erlauben
},
},
}
```
```bash
# Gateway neu starten
systemctl --user restart openclaw-gateway
```
### Schritt 3: macOS Menübar-App als Node verbinden
1. OpenClaw macOS App installieren
2. App öffnen → Settings → Gateway
3. Gateway-URL eingeben: `https://<vps-hostname>.your-tailnet.ts.net`
4. Token eingeben (oder Tailscale-Auth wenn `allowTailscale: true`)
5. Pairing-Request wird auf Gateway erstellt
### Schritt 4: Pairing auf Gateway genehmigen
```bash
# Auf dem VPS:
openclaw devices list # Offene Pairing-Requests anzeigen
openclaw devices approve <requestId>
```
### Schritt 5: Verifizieren
```bash
openclaw nodes status # Node sollte "connected" zeigen
openclaw nodes describe --all # Fähigkeiten aller Nodes anzeigen
```
---
## Szenario: Gateway auf VPS + iPhone als Node
### Schritt 1: Gateway mit Tailscale Serve (wie oben)
### Schritt 2: iOS App installieren und verbinden
1. OpenClaw iOS App aus App Store installieren
2. App öffnen → Settings → Gateway
3. Zwei Optionen:
- **QR-Code**: Im Gateway-Dashboard (WebChat) QR-Code generieren → Scannen
- **Deep Link**: `openclaw://setup?code=<SETUP_CODE>` → In App öffnen
- **Manuell**: Gateway-URL + Token eingeben
### Schritt 3: Pairing via Telegram (bequemster Weg)
```
# Im Telegram-Chat mit dem Bot:
/pair
# → Bot antwortet mit Setup-Code
# → Code in iOS App → Settings → Gateway einfügen
```
### Schritt 4: Genehmigen
```bash
openclaw devices approve <requestId>
```
---
## Szenario: Headless Node (Linux/Pi)
Für Maschinen ohne GUI — nur `system.run` und `system.which`:
```bash
# Auf dem Node-Rechner:
npm install -g openclaw@latest
# Headless Node starten:
openclaw node host --gateway wss://<vps-hostname>.your-tailnet.ts.net \
--token <gateway-token>
# Oder mit TLS:
openclaw node host --gateway wss://<hostname>:18789 \
--tls --tls-fingerprint <fingerprint>
```
Node-Config wird gespeichert in: `~/.openclaw/node.json`
Exec-Approvals: `~/.openclaw/exec-approvals.json`
---
## Szenario: Raspberry Pi als immer-on Node
```bash
# Auf dem Pi:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
npm install -g openclaw@latest
# Als systemd-Service:
cat > ~/.config/systemd/user/openclaw-node.service << 'EOF'
[Unit]
Description=OpenClaw Node Host
After=network-online.target
[Service]
ExecStart=%h/.npm-global/bin/openclaw node host \
--gateway wss://<vps-hostname>.your-tailnet.ts.net \
--token <gateway-token>
Restart=always
RestartSec=10
[Install]
WantedBy=default.target
EOF
systemctl --user daemon-reload
systemctl --user enable --now openclaw-node
```
---
## Node-Discovery (Bonjour/mDNS)
### Lokales Netzwerk (LAN)
- Gateway advertised sich via `_openclaw-gw._tcp` (Bonjour/mDNS)
- macOS/iOS Nodes entdecken Gateway automatisch im LAN
- Kein manuelles URL-Eingeben nötig
### Tailscale-Netzwerk
- mDNS-Broadcasts propagieren nicht über Tailscale
- **Lösung**: DNS-SD über Unicast-DNS (Tailscale DNS-Server)
- Android nutzt `dnsjava` Library für Unicast-DNS-SD
- iOS nutzt QR-First-Pairing wenn kein lokaler Gateway gefunden
---
## Node-Befehle ausführen
```bash
# Befehl auf einem spezifischen Node ausführen
openclaw nodes run --node <idOrNameOrIp> -- echo "Hello from node"
# Benachrichtigung auf Node senden
openclaw nodes notify --node <idOrNameOrIp> \
--title "Ping" --body "Gateway ready" \
--priority active # passive | active | timeSensitive
# Node-Details anzeigen
openclaw nodes describe --node <id>
# Alle Nodes anzeigen
openclaw nodes status
```
---
## Browser-Control über Node
Für Gateway auf Server + Browser auf MacBook:
1. Gateway auf VPS (Tailscale Serve)
2. macOS Node auf MacBook (Menübar-App, selbes Tailnet)
3. Gateway proxied Browser-Aktionen zum Node
4. **Kein separater Serve-URL** nötig
5. **Kein Funnel** für Browser-Control nutzen!
---
## Exec-Approvals (Sicherheit)
Nodes können Shell-Befehle ausführen — das muss kontrolliert werden:
```json5
// ~/.openclaw/exec-approvals.json (auf dem Node)
{
"mode": "ask", // "ask" | "allowlist" | "full"
// ask = Jeder Befehl muss bestätigt werden
// allowlist = Nur bestimmte Befehle erlaubt
// full = Alles erlaubt (GEFÄHRLICH!)
}
```
macOS App: Settings → Exec Approvals (gleiche Modi)
---
## Wichtige Regeln
1. **Nodes sind Peripherie** — Messaging geht über Gateway, nicht über Nodes
2. **Pairing = Vertrauens-Akt** — Setup-Code wie Passwort behandeln!
3. **Kein Funnel für Nodes** — Nur Tailscale Serve oder LAN
4. **exec-approvals** — Auf jedem Node konfigurieren
5. **Node-ID persistent** — Gespeichert in `~/.openclaw/node.json`
6. **PATH-Overrides ignoriert** — Tools in Standard-Locations installieren
```
### references/tailscale-integration.md
```markdown
# Tailscale-Integration — Remote-Zugriff richtig konfigurieren
## Überblick: Drei Zugriffsmodi
| Modus | Wer kann zugreifen | HTTPS | Config |
|---|---|---|---|
| `serve` (empfohlen) | Nur Tailnet-Geräte | ✅ automatisch | `tailscale.mode: "serve"` |
| `funnel` (vorsicht!) | Öffentliches Internet | ✅ automatisch | `tailscale.mode: "funnel"` + Password |
| `tailnet` bind | Tailnet-Geräte | ❌ manuell | `gateway.bind: "tailnet"` |
| SSH-Tunnel | Wer SSH-Zugang hat | ❌ | Kein Config nötig |
**Empfehlung für 99% der Fälle: `serve`**
---
## Tailscale Serve (Tailnet-only, empfohlen)
Gateway bleibt auf `127.0.0.1`, Tailscale proxied HTTPS-Traffic.
Nur Geräte im selben Tailnet können zugreifen.
### Config
```json5
{
gateway: {
bind: "loopback",
tailscale: {
mode: "serve",
resetOnExit: false, // true = tailscale serve reset bei Shutdown
},
auth: {
mode: "token",
token: "<dein-token>",
allowTailscale: true, // Tailscale-Identity-Auth erlauben
},
},
}
```
### CLI-Alternative
```bash
openclaw gateway --tailscale serve
```
### Zugriff
```
https://<hostname>.your-tailnet.ts.net
```
### Auth-Optionen bei Serve
- **allowTailscale: true** → Tailscale-User werden automatisch erkannt (kein Token nötig)
- **allowTailscale: false** → Token/Password trotzdem erforderlich
- OpenClaw verifiziert Tailscale-Identity über `tailscale whois` + Header-Prüfung
---
## Tailscale Funnel (öffentlich, VORSICHT!)
Macht den Gateway über das öffentliche Internet erreichbar.
**Nur nutzen wenn wirklich nötig!**
### Config
```json5
{
gateway: {
bind: "loopback",
tailscale: {
mode: "funnel",
},
auth: {
mode: "password", // PFLICHT bei Funnel!
password: "starkes-passwort-hier",
},
},
}
```
**Besser**: Password über Environment-Variable:
```bash
export OPENCLAW_GATEWAY_PASSWORD="starkes-passwort-hier"
```
### CLI-Alternative
```bash
openclaw gateway --tailscale funnel --auth password
```
### Funnel-Voraussetzungen
- Tailscale v1.38.3+
- MagicDNS aktiviert
- HTTPS aktiviert für das Tailnet
- `funnel` Node-Attribut gesetzt
- Nur Ports 443, 8443, 10000 (TLS)
- macOS: Open-Source Tailscale App-Variante nötig
### Sicherheits-Hinweis
- **Funnel injiziert KEINE Identity-Headers** (anders als Serve)
- Deshalb: Password-Auth PFLICHT
- Funnel weigert sich zu starten ohne `auth.mode: "password"`
---
## Direct Tailnet Bind (ohne Serve/Funnel)
Gateway hört direkt auf der Tailscale-IP — kein HTTPS, kein Proxy.
```json5
{
gateway: {
bind: "tailnet", // Bindet auf Tailscale-IP
auth: {
mode: "token",
token: "<dein-token>",
},
},
}
```
### Zugriff
```
http://<tailscale-ip>:18789
ws://<tailscale-ip>:18789
```
**Achtung**: `http://127.0.0.1:18789` funktioniert in diesem Modus NICHT!
---
## SSH-Tunnel (ohne Tailscale-Config)
Kein Config-Change nötig — Gateway bleibt auf loopback:
```bash
# Von deinem Laptop:
ssh -L 18789:127.0.0.1:18789 user@vps-ip
# Dann lokal zugreifen:
# http://127.0.0.1:18789
```
### Permanenter SSH-Tunnel (systemd)
```bash
# ~/.config/systemd/user/openclaw-ssh-tunnel.service
[Unit]
Description=OpenClaw SSH Tunnel
After=network-online.target
[Service]
ExecStart=/usr/bin/ssh -N -L 18789:127.0.0.1:18789 user@vps-ip
Restart=always
RestartSec=10
[Install]
WantedBy=default.target
```
```bash
systemctl --user enable --now openclaw-ssh-tunnel
```
**Wichtig**: Auch über SSH-Tunnel muss `gateway.auth.token` gesetzt sein!
---
## Praxis-Szenario: VPS + Tailscale + Nodes
### Setup-Reihenfolge
#### 1. Tailscale auf VPS installieren
```bash
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up --ssh # Optional: SSH über Tailscale
tailscale ip -4 # IP notieren
tailscale status # Prüfen
```
#### 2. Tailscale auf allen Nodes installieren
```bash
# MacBook:
brew install tailscale
# iPhone/Android: App Store / Play Store
# Raspberry Pi:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
```
#### 3. Gateway konfigurieren
```json5
// Auf dem VPS: ~/.openclaw/openclaw.json
{
gateway: {
bind: "loopback",
tailscale: { mode: "serve" },
auth: {
mode: "token",
token: "<64-zeichen-token>",
allowTailscale: true,
},
},
}
```
```bash
systemctl --user restart openclaw-gateway
```
#### 4. Dashboard testen
```
https://<vps-hostname>.your-tailnet.ts.net
```
→ Token eingeben → Dashboard sollte laden
#### 5. macOS Node verbinden
- OpenClaw macOS App → Settings → Gateway
- URL: `https://<vps-hostname>.your-tailnet.ts.net`
- Verbinden → Pairing-Request
#### 6. Pairing genehmigen
```bash
# Auf VPS:
openclaw devices list
openclaw devices approve <requestId>
```
#### 7. Verifizieren
```bash
openclaw nodes status # Node connected?
openclaw channels status --probe # Channels OK?
```
---
## Troubleshooting Tailscale
| Problem | Lösung |
|---|---|
| "Serve requires HTTPS" | HTTPS im Tailscale Admin Panel aktivieren |
| Funnel startet nicht | Password-Auth fehlt, oder Tailscale < v1.38.3 |
| Node findet Gateway nicht | `tailscale status` auf beiden Seiten prüfen |
| "device identity required" | HTTPS nötig — SSH-Tunnel oder Tailscale Serve nutzen |
| Dashboard nicht erreichbar | `tailscale serve status` prüfen, Firewall checken |
| allowTailscale funktioniert nicht | Nur bei `serve` Mode, nicht bei `funnel` |
### Diagnose-Befehle
```bash
tailscale status # Tailscale-Verbindung prüfen
tailscale serve status # Serve-Config anzeigen
tailscale ping <hostname> # Erreichbarkeit testen
tailscale whois <ip> # Identity prüfen
```
```
### references/examples.md
```markdown
# Praxis-Beispiele — Typische OpenClaw-Setups
## Beispiel 1: Minimal-Setup für Einsteiger (VPS + Telegram)
**Szenario**: Contabo VPS, Telegram als einziger Kanal, Claude als Modell.
### Config
```json5
// ~/.openclaw/openclaw.json
{
gateway: {
bind: "loopback",
auth: {
mode: "token",
token: "$(openssl rand -hex 32)",
},
},
channels: {
telegram: {
enabled: true,
adapter: "telegram",
// Token via: @BotFather → /newbot
},
},
models: {
default: "anthropic/claude-sonnet-4-20250514",
},
agent: {
heartbeat: {
enabled: false, // Anfangs deaktiviert (spart Tokens)
},
},
}
```
### AGENTS.md (minimal)
```markdown
# Betriebsanweisungen
Du bist mein persönlicher Assistent. Antworte auf Deutsch.
Sei hilfreich, präzise und freundlich.
Bestätige destruktive Aktionen vor der Ausführung.
```
### SOUL.md (minimal)
```markdown
# Persönlichkeit
- Professionell, freundlich, direkt
- Deutsch als Standard
- Verwende gelegentlich das Lobster-Emoji 🦞
```
### Erste Schritte
```bash
# 1. Installieren
curl -fsSL https://get.openclaw.ai | bash
# 2. Wizard durchlaufen (Token, Model, Telegram-Bot)
openclaw setup
# 3. Gateway starten
openclaw gateway install # systemd service
openclaw gateway start
# 4. Health Check
openclaw doctor
openclaw channels status --probe
# 5. In Telegram Bot anschreiben → Fertig!
```
---
## Beispiel 2: VPS + Tailscale + MacBook-Node
**Szenario**: Gateway auf Hetzner VPS, MacBook als Node für Browser-Automation.
### VPS-Setup
```bash
# Tailscale installieren
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
tailscale ip -4 # z.B. 100.64.x.x
```
### Config auf VPS
```json5
{
gateway: {
bind: "loopback",
tailscale: {
mode: "serve",
resetOnExit: false,
},
auth: {
mode: "token",
token: "<token>",
allowTailscale: true,
},
controlUi: {
enabled: true,
},
},
channels: {
telegram: { enabled: true, adapter: "telegram" },
whatsapp: { enabled: true, adapter: "whatsapp" },
},
models: {
default: "anthropic/claude-sonnet-4-20250514",
heartbeat: "anthropic/claude-haiku-3-20250307", // Günstig für Heartbeat
},
}
```
### MacBook einrichten
```bash
# 1. Tailscale installieren + einloggen
brew install tailscale
tailscale up
# 2. OpenClaw macOS App installieren
brew install --cask openclaw
# 3. App öffnen → Settings → Gateway
# URL: https://<vps>.your-tailnet.ts.net
# → Connect → Pairing-Request wird erstellt
# 4. Auf VPS genehmigen:
openclaw devices list
openclaw devices approve <requestId>
# 5. Prüfen:
openclaw nodes status
# → MacBook sollte "connected" sein mit canvas.*, system.* Capabilities
```
### Browser-Automation testen
```
# In Telegram dem Bot schreiben:
"Öffne google.de und suche nach 'OpenClaw Tailscale Setup'"
# → Gateway sendet browser.* Befehle an MacBook-Node
```
---
## Beispiel 3: VPS + iPhone + Raspberry Pi
**Szenario**: Zentraler Gateway, iPhone für unterwegs, Pi für Smart-Home-Kontrolle.
### Architektur
```
Internet / Tailscale
│
┌─────┴──────────────┐
│ Hetzner VPS │ Gateway + Telegram + WhatsApp
│ 100.64.0.1 │ Tailscale Serve
└─────┬──────────────┘
│
┌────┴──────────────────────┐
│ │
┌──┴───────────┐ ┌────────────┴──────┐
│ iPhone │ │ Raspberry Pi 5 │
│ iOS App │ │ Headless Node │
│ 100.64.0.2 │ │ 100.64.0.3 │
│ Kamera, │ │ system.run, │
│ Canvas, │ │ GPIO, Sensoren │
│ Voice │ │ Smart-Home │
└──────────────┘ └───────────────────┘
```
### Pi als Headless Node einrichten
```bash
# 1. Raspberry Pi OS Lite (64-bit) installieren
# 2. SSH aktivieren, Updates
sudo apt update && sudo apt upgrade -y
# 3. Node.js 22+ installieren
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo bash -
sudo apt install -y nodejs
# 4. Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
# 5. OpenClaw (nur Node-Host, kein Gateway!)
npm install -g openclaw@latest
# 6. Node-Host starten
openclaw node host \
--gateway wss://<vps>.your-tailnet.ts.net \
--token <gateway-token>
# 7. Auf VPS genehmigen:
openclaw devices approve <requestId>
```
### Pi Node als systemd-Service
```ini
# ~/.config/systemd/user/openclaw-node.service
[Unit]
Description=OpenClaw Node Host
After=network-online.target
[Service]
ExecStart=%h/.npm-global/bin/openclaw node host \
--gateway wss://<vps>.your-tailnet.ts.net \
--token <gateway-token>
Restart=always
RestartSec=10
Environment=NODE_ENV=production
[Install]
WantedBy=default.target
```
```bash
# loginctl enable-linger nötig für --user services!
loginctl enable-linger $USER
systemctl --user daemon-reload
systemctl --user enable --now openclaw-node
```
### iPhone verbinden
1. OpenClaw iOS App installieren
2. Tailscale iOS App installieren + einloggen
3. In Telegram dem Bot schreiben: `/pair`
4. Setup-Code kopieren → iOS App → Settings → Gateway → Code einfügen
5. Auf VPS: `openclaw devices approve <requestId>`
---
## Beispiel 4: Multi-Agent mit getrennten Workspaces
**Szenario**: Ein persönlicher Agent + ein Arbeits-Agent auf demselben Gateway.
### Config
```json5
{
agents: {
list: [
{
agentId: "alex-privat",
name: "Lobster 🦞",
agentDir: "~/.openclaw/agents/alex-privat",
workspaceDir: "~/.openclaw/workspaces/privat",
},
{
agentId: "alex-arbeit",
name: "WorkBot 🏢",
agentDir: "~/.openclaw/agents/alex-arbeit",
workspaceDir: "~/.openclaw/workspaces/arbeit",
},
],
},
bindings: {
// Telegram → Privat-Agent
"telegram:*": { agentId: "alex-privat" },
// Slack → Arbeits-Agent
"slack:*": { agentId: "alex-arbeit" },
// WhatsApp → Privat (default)
"whatsapp:*": { agentId: "alex-privat" },
// WhatsApp Arbeitsgruppe → Arbeits-Agent
"whatsapp:group:ArbeitsGruppe": { agentId: "alex-arbeit" },
},
}
```
**Regel**: Nie `workspaceDir` zwischen Agents teilen!
---
## Beispiel 5: Kosten-optimiertes Setup
**Szenario**: Monatliche API-Kosten unter 20€ halten.
### Strategie
```json5
{
models: {
// Hauptmodell: Gutes Preis-Leistung
default: "anthropic/claude-sonnet-4-20250514",
// Heartbeat: Billigstes Modell
heartbeat: "anthropic/claude-haiku-3-20250307",
},
agent: {
heartbeat: {
enabled: true,
interval: "4h", // Nur alle 4 Stunden (statt default 1h)
},
session: {
compaction: {
maxTokens: 80000, // Früher compacten
},
},
},
}
```
### HEARTBEAT.md (Minimal!)
```markdown
## Heartbeat-Aufgaben
- [ ] Prüfe ob neue Nachrichten in meinen Channels warten
```
Mehr Tasks = mehr Token-Verbrauch pro Heartbeat!
### Kosten-Monitoring
```bash
# Token-Verbrauch aktueller Session
# In Telegram:
/status
# Historische Kosten (wenn vom Provider unterstützt)
openclaw sessions list --costs
```
### Spar-Tricks
1. **Heartbeat deaktivieren** wenn nicht nötig: `heartbeat.enabled: false`
2. **SSH statt Heartbeat** für Maintenance: Gateway direkt ansprechen
3. **Compaction-Limit senken**: Weniger Context = weniger Tokens
4. **Günstige Modelle für Routing**: `models.heartbeat` separat setzen
5. **Skills minimal halten**: Weniger geladene Skills = weniger System-Prompt-Tokens
---
## Beispiel 6: Sicheres Setup mit Docker-Sandbox
**Szenario**: Maximale Isolation — Agent kann Host nicht beschädigen.
### docker-compose.yml
```yaml
services:
openclaw:
image: ghcr.io/openclaw/openclaw:latest
container_name: openclaw
restart: unless-stopped
user: "1000:1000"
volumes:
- ./data:/home/openclaw/.openclaw
environment:
- OPENCLAW_GATEWAY_TOKEN=${GATEWAY_TOKEN}
- OPENCLAW_GATEWAY_PASSWORD=${GATEWAY_PASSWORD}
ports:
- "127.0.0.1:18789:18789"
security_opt:
- no-new-privileges:true
read_only: true
tmpfs:
- /tmp
networks:
- openclaw-net
networks:
openclaw-net:
driver: bridge
```
### Sandbox-Config
```json5
{
gateway: {
bind: "loopback",
auth: { mode: "token" },
},
agent: {
sandbox: {
enabled: true,
// Agent-Prozesse laufen im Docker-Container
// Host-Zugriff ist vollständig blockiert
},
},
}
```
---
## Beispiel 7: iMessage via BlueBubbles + Linux Gateway
**Szenario**: Gateway auf Linux VPS, iMessage über einen Mac zuhause.
### Architektur
```
VPS (Linux) Mac mini (zuhause)
┌─────────────────┐ ┌─────────────────┐
│ OpenClaw │◄──────────│ BlueBubbles │
│ Gateway │ Tailscale │ Server │
│ (kein macOS │ │ (signed into │
│ nötig!) │ │ Messages) │
└─────────────────┘ └─────────────────┘
```
### Schritte
1. BlueBubbles auf Mac installieren (https://bluebubbles.app)
2. BlueBubbles-Server starten (Mac muss eingeloggt + online bleiben)
3. Beide Geräte im selben Tailnet
4. In openclaw.json:
```json5
{
channels: {
imessage: {
enabled: true,
adapter: "bluebubbles",
// BlueBubbles-Server-URL über Tailscale
host: "http://<mac-tailscale-ip>:1234",
password: "<bluebubbles-password>",
},
},
}
```
---
## Cheat-Sheet: Welches Setup für welchen Zweck?
| Zweck | Gateway | Nodes | Channels | Tailscale |
|---|---|---|---|---|
| Einsteiger / Test | Lokal oder VPS | Keine | Telegram | Optional |
| Always-On Assistant | VPS | MacBook + iPhone | Telegram + WhatsApp | ✅ Serve |
| Smart Home | Raspberry Pi | Weitere Pi's | Telegram | ✅ Serve |
| Max Security | Docker auf VPS | Keine | WebChat only | ✅ Serve |
| Multi-Device | VPS | Mac + iPhone + Pi | Alle | ✅ Serve |
| Kosten-Mini | VPS (1€/Monat) | Keine | Telegram | SSH-Tunnel |
| iMessage | VPS (Linux) | Mac (BlueBubbles) | iMessage + Telegram | ✅ Serve |
```
### references/troubleshooting.md
```markdown
# Troubleshooting — Häufige Probleme & Lösungen
## Diagnose-Grundlagen
```bash
# IMMER zuerst:
openclaw --version
openclaw doctor
openclaw status
# Logs lesen:
journalctl --user -u openclaw-gateway -n 50 --no-pager
# oder:
tail -n 120 /tmp/openclaw-gateway.log
# Docker:
docker compose logs -f openclaw-gateway
```
---
## Gateway startet nicht nach Config-Änderung
```bash
# 1. Config validieren
openclaw doctor
# 2. JSON5-Syntax prüfen
node -e "require('fs').readFileSync(process.env.HOME+'/.openclaw/openclaw.json','utf8')" && echo "OK"
# 3. Logs analysieren
journalctl --user -u openclaw-gateway -n 50 --no-pager
tail -n 120 /tmp/openclaw-gateway.log
# 4. Port belegt?
ss -ltnp | grep 18789
# 5. Backup wiederherstellen
cp ~/.openclaw/openclaw.json.bak ~/.openclaw/openclaw.json
systemctl --user restart openclaw-gateway
```
**Häufigste Ursache**: Unbekannter Key oder falscher Typ in openclaw.json.
JSON5 erlaubt Kommentare, aber keine unbekannten Felder!
---
## "systemctl --user unavailable"
```bash
# Falsch: Als root eingeloggt
# Richtig: Als openclaw-User einloggen
ssh openclaw@<server-ip>
# Dann:
openclaw gateway install
systemctl --user start openclaw-gateway
systemctl --user enable openclaw-gateway
# Wenn lingering fehlt:
loginctl enable-linger openclaw
```
---
## Modell hinzufügen schlägt fehl
```bash
# Fallstricke:
# 1. "id" muss "provider/model-name" Format haben
# 2. Bei OpenRouter-Style IDs: Provider-Prefix dazu!
# z.B. "openrouter/moonshotai/kimi-k2"
# 3. "api": "openai-completions" vs "openai-responses" (versionsabhängig!)
# 4. "contextWindow" und "maxTokens" müssen Zahlen sein, keine Strings!
# 5. Ollama in Docker: baseUrl = "http://host.docker.internal:11434"
```
---
## Node verbindet nicht
```bash
openclaw nodes status
openclaw channels status --probe
# Gateway muss von Node erreichbar sein:
# - Tailscale: gateway.bind auf "tailscale" setzen
# - Lokales Netz: gateway.bind auf "lan" (nur mit VPN!)
# - Port 18789 muss erreichbar sein
```
---
## Skills werden nicht geladen
```bash
# Skills erst in neuer Session aktiv!
openclaw gateway restart
# Dann prüfen:
openclaw skills list
# Skill-Verzeichnisse prüfen:
ls ~/.openclaw/workspace/skills/ # Workspace-Skills
ls ~/.openclaw/skills/ # Managed-Skills
# Nur 1 von N Skills sichtbar?
# → SKILL.md prüfen:
# - YAML-Frontmatter mit name + description?
# - Kein Syntax-Fehler im YAML?
# - Doppelpunkte in description mit Quotes escapen!
```
---
## Heartbeat-Probleme
### Heartbeat-Model-Bug (Issue #22133)
```
Symptom: Main-Session plötzlich mit 16k Context statt 200k
Ursache: heartbeat.model überschreibt main-Session-Model
Fix: heartbeat.model entfernen oder auf gleiches Model setzen
Workaround: /new in Telegram → Modell wird zurückgesetzt
```
### Heartbeat verbraucht zu viele Tokens
```json5
agent: {
heartbeat: {
every: "6h", // Von "30m" auf "6h" reduzieren
// oder:
every: "off", // Heartbeat komplett deaktivieren
},
}
```
---
## Memory-Probleme
### Memory wird nicht gefunden
```bash
# memorySearch aktiv?
openclaw config get agents.defaults.memorySearch.enabled
# Embedding-Provider konfiguriert?
# Auto-Detect: local → openai → gemini
# Manuell prüfen: API-Key für Embeddings vorhanden?
# Erster Aufruf langsam → QMD lädt GGUF-Modelle herunter
```
### Memory geht bei Compaction verloren
```json5
// memoryFlush aktivieren:
agents: {
defaults: {
compaction: {
memoryFlush: { enabled: true },
},
},
}
```
### MEMORY.md wird in Gruppen geladen (Datenschutz!)
→ Das sollte NICHT passieren. MEMORY.md wird nur in privaten Sessions geladen.
Falls doch: `openclaw doctor` + Version updaten.
---
## WhatsApp-Probleme
| Problem | Lösung |
|---|---|
| QR-Code abgelaufen | `openclaw channels login` erneut |
| Bot antwortet nicht | `openclaw channels status --probe` |
| Fremde können schreiben | `dmPolicy: "allowlist"` + `allowFrom` prüfen |
| Bot in Gruppen zu geschwätzig | Gruppen-Verhalten in AGENTS.md regeln |
---
## Performance-Probleme
| Problem | Lösung |
|---|---|
| Langsame Antworten | Model-Latenz prüfen, ggf. kleineres Model |
| Hohe Kosten | Heartbeat-Intervall erhöhen, günstigeres Model |
| Docker langsam auf macOS | npm-Installation statt Docker nutzen |
| Context-Compaction zu häufig | Größeres Model-Context-Window nutzen |
| Memory-Search langsam | Erster Aufruf = Model-Download, danach schneller |
---
## Notfall: Komplett zurücksetzen
```bash
# 1. Gateway stoppen
systemctl --user stop openclaw-gateway
# 2. Backup (!)
tar czf ~/openclaw-emergency-backup-$(date +%Y%m%d).tar.gz ~/.openclaw/
# 3. Config zurücksetzen
openclaw onboard # Wizard erneut durchlaufen
# 4. Oder: Backup-Config wiederherstellen
cp ~/.openclaw/openclaw.json.bak ~/.openclaw/openclaw.json
# 5. Neu starten
systemctl --user start openclaw-gateway
openclaw doctor
```
```
### references/tricks-and-hacks.md
```markdown
# Tricks & Hacks — Power-User-Tipps
## Kosten-Optimierung
### Token-Verbrauch senken
```json5
agent: {
heartbeat: {
every: "6h", // Statt "30m" → spart 90%+ der Heartbeat-Kosten
},
},
agents: {
defaults: {
compaction: {
mode: "safeguard", // Kompaktiert intelligent
reserveTokensFloor: 20000,
},
},
}
```
### Hybrid-Modell-Strategie
- **Heartbeat + Simple Tasks**: Günstiges lokales Model (Ollama/llama3.2)
- **Komplexe Aufgaben**: Claude Sonnet/Opus via API
- **ACHTUNG**: heartbeat.model Bug kann in main-Session bluten (Issue #22133)
### Zero-Token-Wartung
Direkt per SSH/VS Code Dateien bearbeiten statt Bot-Befehle:
```bash
# SSH-Zugriff für Cursor/VS Code:
# File → New Window → Connect with SSH → user@server
# Dann SOUL.md, Skills, Configs direkt editieren = 0 Token-Kosten
```
---
## Produktivitäts-Hacks
### Web-Prototyping on the go
```
Prompt an Bot: "Recherchiere X, mach mir eine HTML-Seite und hoste sie auf Surge"
```
→ Bot erstellt und deployed eine Webseite, teilbar per Link
### Obsidian-Integration
- Obsidian Vault ($5/mo) auf OpenClaw-Maschine einrichten
- Agent kann in Vault lesen und schreiben
- Persönlicher Knowledge-Graph + Task-Management per Chat
→ WhatsApp/Voicenote → Agent durchsucht Vault → Antwort
### Session-Management
```
/status — Was läuft gerade? (Model, Tokens, Kosten)
/new — Frische Session (bei verwirrendem Kontext)
/compact — Manuell kompaktieren (bei langer Session)
```
### Memory-Tricks
```
# Explizit Memory schreiben lassen:
"Merke dir in USER.md, dass ich kurze Antworten mit Code-Beispielen will"
"Schreibe in MEMORY.md: Projekt X nutzt Docker Compose auf Contabo"
"Aktualisiere memory/ mit der heutigen Entscheidung zu Y"
# Memory-Review forcieren:
"Lies MEMORY.md und entferne alles was veraltet ist"
"Konsolidiere die letzten 7 Tage aus memory/ in MEMORY.md"
```
---
## Fortgeschrittene Config-Tricks
### Mehrere Workspaces testen
```bash
# Workspace-A für Produktion, Workspace-B zum Testen
cp -r ~/.openclaw/workspace ~/.openclaw/workspace-test
# In openclaw.json temporär umschalten:
# agents.defaults.workspace: "~/.openclaw/workspace-test"
# ACHTUNG: Nur EIN aktiver Workspace — sonst State-Drift!
```
### Custom System-Prompt über AGENTS.md
```markdown
# In AGENTS.md hinzufügen:
## Antwort-Format
- Immer zuerst eine Zusammenfassung in einem Satz
- Dann technische Details
- Code-Beispiele mit Kommentaren
- Sprache: Deutsch, Tech-Begriffe auf Englisch OK
```
### Crash-Recovery-Watchdog
```bash
# systemd-Watchdog (automatischer Neustart bei Crash):
# ~/.config/systemd/user/openclaw-gateway.service
[Service]
Restart=always
RestartSec=10
WatchdogSec=300
```
### Logging nach Supabase
- Supabase Free-Tier als Logging-Backend
- Dashboard zeigt jede Interaktion
- Kosten-Monitoring bei API-Key-Kompromittierung
- Bot kann Supabase-Setup selbst konfigurieren
---
## Workspace Git-Workflow
```bash
# Automatisches Backup nach jeder Änderung
cd ~/.openclaw/workspace
# .gitignore für sensible Daten
cat > .gitignore << 'EOF'
# Keine Credentials committen!
*.key
*.token
*.secret
EOF
# Pre-Commit-Hook für automatische Backups
cat > .git/hooks/post-commit << 'EOF'
#!/bin/bash
git push origin main 2>/dev/null || true
EOF
chmod +x .git/hooks/post-commit
```
---
## Nützliche Einzeiler
```bash
# Alle aktiven Sessions mit Kosten anzeigen
openclaw sessions list
# Config-Diff nach Änderung
diff ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bak
# Memory-Größe prüfen
wc -l ~/.openclaw/workspace/MEMORY.md
du -sh ~/.openclaw/workspace/memory/
# Alte Memory-Dateien aufräumen (älter als 30 Tage)
find ~/.openclaw/workspace/memory/ -name "*.md" -mtime +30 -ls
# Gateway-Health-Check (API)
curl -s http://127.0.0.1:18789/health
# Alle Channels auf einmal testen
openclaw channels status --probe
# Exposed Secrets finden
grep -rn "sk-\|api_key\|token\|secret" ~/.openclaw/workspace/ --include="*.md"
```
---
## Integration mit anderen Tools
### n8n-Webhooks
- OpenClaw kann Webhooks empfangen/senden
- n8n-Workflow → Webhook → OpenClaw verarbeitet → Antwort an Channel
- Nützlich für: E-Mail-Zusammenfassungen, RSS-Alerts, Monitoring
### Tailscale für Remote-Zugriff
```json5
gateway: {
mode: "tailscale",
bind: "tailscale", // Nur über Tailscale-Netzwerk erreichbar
}
```
→ Dashboard + WebChat von überall erreichbar, aber sicher
### Docker Model Runner (komplett lokale LLMs)
```bash
# Docker Model Runner + OpenClaw in Docker Sandbox
# = 0 API-Kosten, volle Privatsphäre
docker model pull llama3.2:latest
# OpenClaw zeigt alle Docker Model Runner Modelle automatisch
```
---
## "Erste Woche"-Leitfaden
1. **Tag 1-2**: Nur chatten. Wetter fragen, Artikel zusammenfassen, Smalltalk.
2. **Tag 3**: SOUL.md und USER.md anpassen. Ton und Präferenzen definieren.
3. **Tag 4**: Erste echte Aufgabe: E-Mail-Draft, Code-Review, Recherche.
4. **Tag 5**: HEARTBEAT.md einrichten. Regelmäßige Check-ins definieren.
5. **Tag 6**: Memory-System testen. "Merke dir X", am nächsten Tag prüfen.
6. **Tag 7**: Ersten Custom-Skill erstellen oder ClawHub-Skill installieren.
→ Nach einer Woche Korrekturen klingt dein Agent komplett anders als am Anfang.
**Das ist der Punkt.**
---
## Bekannte Gotchas (Stand 02/2026)
1. **heartbeat.model Bug** → Kann main-Session-Model überschreiben (#22133)
2. **Skills nur in neuer Session** → Nach install/reload: Gateway restart ODER /new
3. **Mehrere Workspaces** → `openclaw doctor` warnt, nur einen aktiv halten
4. **WhatsApp DM-Policy** → Global pro Account, nicht pro Agent
5. **MEMORY.md in Groups** → Sollte nie passieren, falls doch: Update + Doctor
6. **Docker macOS** → Langsamer als npm direkt, nur nutzen wenn Isolation nötig
7. **Context-Window** → Heartbeat kann mit 16k Model Context-Compaction-Loop auslösen
8. **Supabase-Leak (historisch)** → Moltbook-Incident Januar 2026, inzwischen gefixt
```
---
## Skill Companion Files
> Additional files collected from the skill directory layout.
### _meta.json
```json
{
"owner": "arn0ld87",
"slug": "openclaw-expert",
"displayName": "Openclaw Expert",
"latest": {
"version": "1.0.0",
"publishedAt": 1772273452004,
"commit": "https://github.com/openclaw/skills/commit/1c43acfa3eabd96271809ddddb67e0df79cb60fb"
},
"history": []
}
```