Dit is de complete OpenClaw-fieldguide, gepresenteerd door Vic Boomer als onderdeel van de OpenClaw-publicatie. Geen samenvatting, geen interpretatie, geen weglatingen. Voor een geïnterpreteerde lezing, kies een andere Vic Pil op de body-pagina.

OpenClaw Field Guide

Een praktische gids voor installatie, architectuur en gebruik van OpenClaw. Deze handleiding combineert de conceptuele principes achter het systeem met technische instructies die je stap voor stap volgt.

Documentatie bijgewerkt tot v2026.5.22. OpenClaw evolueert in een hoog tempo. Alles in dit document beschrijft hoe het systeem op die versie werkt. Latere releases voegen functies toe of bouwen iets om, en in zeldzame gevallen verdwijnt iets weer. Voor de actuele canonieke documentatie zie docs.openclaw.ai; deze veldgids is een zorgvuldige snapshot, niet een levend referentiewerk.

De field guide is geschreven als companion bij de architectuurdocumenten in vicboomer/. Die geven de technische diepgang; dit document geeft je het totaalplaatje en de handen.

Wat OpenClaw eigenlijk is

OpenClaw is een persoonlijke AI-agent runtime die lokaal draait. Je praat ermee zoals je met een persoon chat — via de eigen OpenClaw iOS/Android/macOS app (de meest directe weg, met voice, camera en locatie), of via messaging-platforms zoals Telegram, Discord, Slack, Signal, iMessage en — met opgepast! — WhatsApp. In plaats van een webinterface praat je met je AI zoals je met een persoon chat.

Dat is een belangrijk verschil.

De meeste AI-tools werken volgens het model:

vraag → antwoord → klaar

OpenClaw is ontworpen voor:

persoon → agent → samenwerking → automatisering

Je Claw wordt een digitale collega, niet een chatbot. Hij leeft in je bestaande gesprekken, onthoudt waar je mee bezig bent, en kan zelfstandig handelen.

Wat een Claw uniek maakt

Persoonlijkheid

Elke Claw heeft een eigen identiteit, vastgelegd in bestanden als SOUL.md en IDENTITY.md. Hierin staat tone of voice, gedrag, voorzichtigheid, en stijl. Daardoor ontstaat een consistent karakter — niet een generieke assistent die elke keer opnieuw begint.

Geheugen

Een Claw onthoudt informatie over jouw voorkeuren, lopende projecten en eerdere gesprekken. Dit gebeurt via MEMORY.md en USER.md. Het geheugen wordt automatisch meegenomen in elke interactie — de agent weet wie je bent en waar je mee bezig was.

Proactief gedrag

Een Claw kan zelfstandig taken uitvoeren via een mechanisme dat heartbeat heet. Elke X minuten controleert de agent triggers: nieuwe e-mails, agendawijzigingen, notificaties. Voorbeelden:

• Dagelijkse briefing sturen
• Conflicten in je agenda detecteren
• Inbox prioriteren
• Vlucht check-in doen

De regels hiervoor staan in HEARTBEAT.md.

Zelf uitbreiden

Een van de belangrijkste ideeen achter OpenClaw is dat een Claw nieuwe capabilities kan bouwen. Wanneer je vraagt om iets dat nog niet kan, kan de agent nieuwe code schrijven, een integratie bouwen, of een tool toevoegen. “Kun je elke ochtend mijn e-mail samenvatten?” — de Claw kan dan zelf een Gmail-integratie maken, een scheduled task aanmaken, en een rapport genereren.

Architectuur in het kort

OpenClaw bestaat uit drie lagen:

INTERFACES    →  waar je met de agent praat
     ↓            (WhatsApp, Telegram, Discord, CLI, web dashboard)
GATEWAY       →  het centrale systeem
     ↓            (berichten routeren, sessies beheren, authenticatie, security)
SERVICES      →  verbindingen met de buitenwereld
                  (LLM providers, messaging platforms, browser, filesystem)

De Gateway is het hart: een enkel Node.js-proces dat WebSocket en HTTP combineert, alle kanalen beheert, en de agent-runtime draait. Alles draait lokaal op jouw hardware — alleen de API-calls naar het LLM verlaten je netwerk.

Begrippen die je gaat tegenkomen

Voordat we verder gaan, een korte introductie van de termen die in de rest van dit document zonder uitleg terugkomen. Niemand wil halverwege Deel 7 alsnog opzoeken wat een “session” is.

• Claw is een individuele agent met eigen persoonlijkheid, geheugen en kanaalverbindingen. Een OpenClaw-runtime kan meerdere Claws tegelijk draaien, elk met een eigen workspace.
• Gateway is het centrale Node.js-proces dat alle kanalen, sessies en agent-runs orkestreert. Eén gateway per machine; de Claws leven erbinnen.
• Daemon is de gateway wanneer hij als achtergrondservice draait (via launchd op macOS, systemd op Linux, of de macOS-menubar-app), zodat je niet zelf een terminal open hoeft te houden.
• Workspace is de map (standaard ~/.openclaw/workspace/) met de markdown-bestanden die een Claw zijn persoonlijkheid en geheugen geven. Elke Claw heeft één workspace.
• Channel is een verbinding met een messaging-platform (WhatsApp, Telegram, Slack, Discord, en zo verder) of een directe interface (iOS-app, macOS-app, TUI). Eén Claw kan op meerdere channels tegelijk aanwezig zijn.
• Session is een doorlopend gesprek tussen jou en een Claw, met geheugen tussen beurten. Sessies zijn gebonden aan een channel plus peer; verschillende chats zijn verschillende sessies.
• Skill is een herbruikbare vaardigheid, opgeslagen als een mapje met een SKILL.md (instructie plus metadata). De Claw weet wanneer hij een skill kan aanroepen.
• Tool is een primitieve actie die de Claw kan uitvoeren, bijvoorbeeld een bestand lezen, een webpagina openen, een bash-commando draaien. Skills zijn opgebouwd uit tools.
• Heartbeat is een interne timer die de Claw periodiek wakker maakt zonder dat jij iets stuurt. Hierdoor kan hij proactief taken doen, geheugen onderhouden, herinneringen sturen.
• Soul is het bestand SOUL.md in de workspace dat de persoonlijkheid en waarden van de Claw vastlegt. Wordt bij elke sessie als systeem-context geladen.
• Memory is alles wat de Claw onthoudt tussen sessies door: korte-termijn (MEMORY.md), dagnotities, en optioneel een vector-index voor semantisch zoeken.

Mocht je het later kwijt zijn, deze sectie staat er nog steeds.

Hoe je met een Claw werkt

De grootste fout die mensen maken is hun Claw gebruiken als een zoekmachine.

Niet doen:

Vraag → Antwoord → Klaar

Wel doen:

Project → Samenwerken → Itereren → Automatiseren

Zie je Claw als een assistent, onderzoeker, planner en operator. Niet als een chatbot. Geef context, deel projecten, laat de agent meedenken. Hoe meer je deelt, hoe beter de agent wordt.

Voorbeelden van dagelijks gebruik

Daily briefing — Elke ochtend een overzicht van je agenda, belangrijke mails en nieuws.

Inbox triage — Agent leest e-mails en sorteert: urgent, reply nodig, archiveren.

Planning assistent — Agent herplant taken wanneer meetings uitlopen.

Research assistent — Agent leest documenten, doorzoekt het web, en maakt samenvattingen.

Smart home — “Doe het licht in de woonkamer uit” via WhatsApp.

Code review — Agent bekijkt een PR, vat de wijzigingen samen, en stuurt het resultaat naar Telegram.

Van concept naar praktijk

De rest van deze field guide brengt bovenstaande principes in de praktijk. Elk deel bouwt voort op het vorige — van installatie tot multi-agent setups met geheugen, automatisering en sandboxing. Volg het in volgorde, of spring naar het deel dat je nodig hebt als je al draait.

Deel 1: Installatie en eerste start

Wat je nodig hebt

• macOS, Linux of Windows (macOS is best getest)
• Node.js 22+ — OpenClaw is TypeScript, draait op Node
• Minimaal één LLM API-key — Anthropic Claude is de aanbevolen eerste keuze

Node.js installeren

node --version
# Moet v22.x.x of hoger tonen. Zo niet:
brew install node@22

OpenClaw installeren

npm install -g openclaw@latest

Controleer:

openclaw --version

Troubleshooting: command not found

npm prefix -g
# Voeg het pad toe aan ~/.zshrc:
export PATH="$(npm prefix -g)/bin:$PATH"

macOS sharp-probleem:

SHARP_IGNORE_GLOBAL_LIBVIPS=1 npm install -g openclaw@latest

De onboarding wizard

openclaw onboard --install-daemon

De wizard begeleidt je door vier stappen:

1. Gateway-authenticatie — token instellen (genereer met openssl rand -hex 32)
2. LLM-provider — API-key invullen (Anthropic, OpenAI, Gemini, of een ander)
3. Eerste kanaal — WhatsApp, Telegram, Discord, of later
4. Daemon installatie — gateway als achtergrondservice

Na afloop draait de gateway. Controleer:

openclaw status

Wat er nu op je machine staat

~/.openclaw/
├── openclaw.json          ← Hoofdconfiguratie
├── workspace/             ← Agent workspace (persoonlijkheid, geheugen, skills)
│   ├── SOUL.md            ← Persoonlijkheid en waarden
│   ├── IDENTITY.md        ← Naam en emoji
│   ├── USER.md            ← Informatie over jou
│   ├── AGENTS.md          ← Operationele regels
│   ├── MEMORY.md          ← Langetermijngeheugen
│   └── HEARTBEAT.md       ← Proactieve taken
├── sessions/              ← Gesprekstranscripten
├── credentials/           ← Auth tokens (0600 permissions)
└── cron/                  ← Geplande taken

Deel 2: Security — voordat je verder gaat

Dit is het belangrijkste deel. OpenClaw heeft krachtige beveiligingsopties, maar je moet ze activeren. Sla dit niet over.

Security audit draaien

openclaw security audit

Repareer automatisch wat kan:

openclaw security audit --fix

De zes controles die je MOET doen

1. Gateway bindt op localhost

// ~/.openclaw/openclaw.json
{
  gateway: {
    bind: "loopback"  // Standaard en veiligst. NOOIT "lan" zonder auth.
  }
}

2. Gateway-authenticatie staat aan

{
  gateway: {
    auth: {
      mode: "token",
      token: "${OPENCLAW_GATEWAY_TOKEN}"  // Via env var, NOOIT hardcoded
    }
  }
}

3. DM-beleid staat op pairing

{
  channels: {
    whatsapp: { dmPolicy: "pairing" }
  }
}

De vier opties:

4. Bestandsrechten

chmod 700 ~/.openclaw
chmod 600 ~/.openclaw/openclaw.json

Als ~/.openclaw/ in een cloud-sync map staat (iCloud, Dropbox): verplaats het. Je credentials worden anders gesynchroniseerd.

5. Tool-beperkingen instellen

Als je OpenClaw als chat-assistent gebruikt (niet als dev-tool):

{
  tools: {
    profile: "messaging",
    deny: ["group:automation", "group:runtime", "group:fs"],
    fs: { workspaceOnly: true },
    exec: { security: "deny", ask: "always" },
    elevated: { enabled: false }
  }
}

6. Groepen vereisen @mention

{
  channels: {
    whatsapp: {
      groups: { "*": { requireMention: true } }
    }
  }
}

Veilige startconfiguratie (copy-paste)

{
  gateway: {
    mode: "local",
    bind: "loopback",
    auth: {
      mode: "token",
      token: "${OPENCLAW_GATEWAY_TOKEN}"
    }
  },
  session: {
    dmScope: "per-channel-peer"
  },
  tools: {
    profile: "messaging",
    deny: ["group:automation", "group:runtime", "group:fs", "sessions_spawn", "sessions_send"],
    fs: { workspaceOnly: true },
    exec: { security: "deny", ask: "always" },
    elevated: { enabled: false }
  },
  channels: {
    whatsapp: {
      dmPolicy: "pairing",
      groups: { "*": { requireMention: true } }
    }
  }
}

Deel 3: Je eerste kanaal verbinden

Begin met één kanaal. Voeg pas meer toe als de eerste werkt.

WhatsApp

⚠️ Ban-risico: gebruik NOOIT je eigen hoofdnummer.

WhatsApp heeft géén officiële Bot API voor persoonlijke accounts. OpenClaw verbindt via Baileys — een community-library die het WhatsApp Web-protocol reverse-engineered. Dit valt onder WhatsApp’s “unauthorized clients”-clausule in hun ToS, en WhatsApp’s ML-systeem herkent automation-patterns (snelle replies, 24/7 actief, bot-gedrag). De ban geldt het telefoonnummer, niet OpenClaw — als je je hoofdnummer linkt, kun je je hele WhatsApp-leven kwijtraken (zakelijke contacten, familie, groepen, alles).

Wat dan wel?

• Een tweede nummer (eSIM, virtual number zoals Twilio, een oude Pixel met een prepaid SIM)
• Een dedicated bot-nummer dat alleen voor deze use-case bestaat
• Voor commercieel/multi-user gebruik: de officiële WhatsApp Business API (via Twilio/Meta) — OpenClaw heeft daar geen built-in channel voor, maar je kunt het via een eigen plugin koppelen

Verder beperken: dmPolicy: "allowlist" (geen "pairing" voor publiek bereikbare bots), allowFrom met expliciete nummers, geen volume of frequentie waardoor je als bot opvalt.

openclaw channels login
# Scan de QR-code met je telefoon (zorg dat het je tweede nummer is!)

WhatsApp gebruikt Baileys (geen officiële API). De sessie verloopt periodiek — koppel opnieuw met openclaw channels login.

Telegram

1. Maak een bot via @BotFather
2. Voeg het token toe:

export TELEGRAM_BOT_TOKEN="123456:ABC..."

3. Herstart de gateway of wacht op hot reload

Discord

1. Maak een bot in het Discord Developer Portal
2. Zet Message Content Intent aan
3. Voeg het token toe:

export DISCORD_BOT_TOKEN="jouw-token"

Controleren of het werkt

openclaw channels status
openclaw channels status --probe  # Diepere check

Stuur een testbericht naar je bot. Als alles goed is, krijg je een antwoord.

Deel 4: LLM-providers instellen

API-keys via environment variables

Voeg toe aan ~/.zshrc:

export ANTHROPIC_API_KEY="sk-ant-jouw-key"
# Optioneel:
export OPENAI_API_KEY="sk-..."
export GEMINI_API_KEY="..."
export OPENROUTER_API_KEY="sk-or-..."

Zet API-keys nooit direct in openclaw.json. Gebruik altijd ${VAR_NAME} syntax.

Beschikbare providers

Model instellen

openclaw models set anthropic/claude-sonnet-4-5

Of in config:

{
  agents: {
    defaults: {
      model: {
        primary: "anthropic/claude-sonnet-4-5",
        fallbacks: ["openai/gpt-5.2"]
      }
    }
  }
}

De fallback chain probeert modellen in volgorde. Bij een auth-fout wordt eerst de API-key geroteerd; pas als alle keys uitgeput zijn gaat het naar het volgende model.

Multi-key rotatie

Meerdere API-keys van dezelfde provider:

export ANTHROPIC_API_KEYS="key1,key2,key3"

OpenClaw roteert automatisch bij rate limits of billing errors.

Lokaal model via Ollama

ollama pull llama3.3

{
  agents: {
    defaults: {
      model: { primary: "ollama/llama3.3" }
    }
  }
}

Ollama wordt automatisch ontdekt als het draait op localhost:11434. OpenClaw detecteert vision-capability via /api/show, dus als een Ollama-model multimodal is wordt de juiste image media type automatisch ingesteld zodat je plaatjes kunt sturen.

Amazon Bedrock (AWS)

{
  models: {
    providers: {
      bedrock: {
        region: "eu-central-1",
        // IAM auth via @aws/bedrock-token-generator (default als AWS-credentials beschikbaar zijn)
      }
    }
  }
}

OpenClaw doet inference profile discovery en region injection automatisch. Voor Bedrock-modellen die alleen via OpenAI-compatible endpoints beschikbaar zijn, gebruik je bedrock-mantle/<model>.

Bedrock kan ook als embedding-provider voor memory search worden gebruikt — handig als je memoryCore volledig binnen AWS wil houden.

Eigen endpoint (LM Studio, vLLM, SGLang)

{
  models: {
    providers: {
      lmstudio: {
        baseUrl: "http://localhost:1234/v1",
        apiKey: "lmstudio",
        api: "openai-completions",
        models: [
          { id: "minimax-m2.5", name: "MiniMax M2.5", contextWindow: 200000 }
        ]
      }
    }
  }
}

Fast mode (lagere latency)

{
  agents: {
    defaults: {
      model: {
        params: { fast_mode: true }
      }
    }
  }
}

Werkt met Anthropic (service_tier: "auto") en OpenAI. Cron jobs gebruiken standaard fast mode.

Tiered pricing en sessie-kosten

Veel moderne modellen rekenen verschillende prijzen voor cache-hits, cache-misses en verschillende input/output tiers. OpenClaw houdt sessie-kosten als snapshot bij (niet cumulatief opgeteld), zodat het bedrag dat je in de UI ziet overeenkomt met de werkelijke afrekening, ook bij lange sessies of mid-sessie modelwissels.

openclaw infer — directe inference

Nieuw sub-CLI voor directe LLM-interactie zonder agent-loop:

openclaw infer "Vertaal dit naar Engels: Hallo wereld"
openclaw infer image "Een kat op een skateboard"
openclaw infer tts "Goedemorgen" --voice shimmer
openclaw infer search "OpenClaw release notes"

Handig voor scripts, one-shots en quick tests. Documentatie: docs/cli/capability.md.

Handige commando’s

openclaw models list             # Beschikbare modellen
openclaw models status           # Auth status per provider
openclaw models fallbacks list   # Fallback chain
openclaw models fallbacks add openai/gpt-5.2
openclaw models aliases add opus anthropic/claude-opus-4-6
openclaw infer "vraag"           # Directe inference

Deel 5: Je agent personaliseren

De agent leest bij elke sessie een set markdown-bestanden uit de workspace. Dit is zijn “persoonlijkheid” en “geheugen”.

IDENTITY.md — naam en uitstraling

Name: Atlas
Emoji: 🏛️

De agent gebruikt deze naam in gesprekken en de emoji verschijnt in kanaalberichten.

SOUL.md — persoonlijkheid en grenzen

# Persoonlijkheid
Je bent een pragmatische assistent met een droge humor.
Je geeft beknopte antwoorden tenzij expliciet om detail gevraagd.

# Grenzen
- Geef nooit medisch of juridisch advies
- Verwijs bij gevoelige onderwerpen naar professionals
- Wees eerlijk als je iets niet weet

USER.md — informatie over jou

# Tom
- Software architect, gevestigd in Amsterdam
- Tijdzone: Europe/Amsterdam
- Communiceert in het Nederlands
- Werkt met TypeScript, Swift, Kotlin
- Gebruikt Obsidian voor documentatie

Hoe meer je hier schrijft, hoe beter de agent op jou afstemt.

AGENTS.md — operationele regels

# Werkwijze
- Gebruik Markdown in antwoorden
- Voeg bronverwijzingen toe waar mogelijk
- Bij code-vragen: lees altijd eerst de relevante bestanden
- Sla belangrijke informatie op in memory/

MEMORY.md — langetermijngeheugen

Dit bestand wordt automatisch in elke system prompt geïnjecteerd (max 20.000 tekens). De agent ziet het bij elke beurt zonder tools aan te roepen.

# Langetermijngeheugen

## Projecten
- OpenClaw documentatie: 24 hoofdstukken in vicboomer/
- Pantion: dialog protocol voor intent convergentie

## Voorkeuren
- Beknopt en technisch
- Nederlandse communicatie

De agent kan dit zelf ook bijwerken. Na verloop van tijd groeit dit bestand organisch.

HEARTBEAT.md — proactieve taken

# Taken bij elke check-in

## Dagelijks
- Check of er ongelezen herinneringen zijn in memory/
- Samenvatting van lopende projecten updaten in MEMORY.md

## Wekelijks (maandag)
- Weekoverzicht schrijven naar memory/

Deel 6: Geheugen — hoe de agent onthoudt

OpenClaw heeft drie lagen geheugen:

Automatische memory flush

Als een sessie bijna de context-window limiet bereikt, schrijft de agent automatisch belangrijke feiten naar memory/YYYY-MM-DD.md voordat het transcript wordt gecompacteerd. Dit voorkomt geheugensverlies bij lange gesprekken.

Bij /reset of /new wordt hetzelfde gedaan — de agent slaat feiten op voordat het transcript gewist wordt.

Semantisch zoeken activeren

{
  agents: {
    defaults: {
      memorySearch: {
        enabled: true,
        provider: "openai",
        model: "text-embedding-3-small"
      }
    }
  }
}

Nu kan de agent memory_search "onderwerp" gebruiken om in alle dagnotities te zoeken. De zoekresultaten combineren vector-similarity met tekstmatch en tijdsverval (recentere notities scoren hoger).

Multimodal geheugen (afbeeldingen en audio)

Je kunt ook foto’s en audio-opnames indexeren:

{
  agents: {
    defaults: {
      memorySearch: {
        multimodal: {
          enabled: true,
          modalities: ["image", "audio"]
        },
        provider: "gemini",
        model: "gemini-embedding-2-preview",
        fallback: "none"
      }
    }
  }
}

Ondersteunde types: .jpg, .png, .webp, .gif, .heic (afbeeldingen), .mp3, .wav, .ogg, .m4a, .flac (audio).

Lokale embeddings (geen API-kosten)

{
  agents: {
    defaults: {
      memorySearch: {
        provider: "local",
        local: {
          modelPath: "hf:ggml-org/embedding-model.gguf",
          modelCacheDir: "~/.openclaw/models"
        },
        fallback: "openai"  // Fallback als lokaal faalt
      }
    }
  }
}

Sleep phases en aging

memory-core heeft een gefaseerde lifecycle: in plaats van één opaak “dreaming”-proces zijn er configureerbare sleep phases (slapen, REM-preview, wakker schrijven). Je kunt per agent een retention/cleanup beleid instellen:

{
  agents: {
    defaults: {
      memoryCore: {
        dreamingAging: {
          retentionDays: 365,
          autoCleanup: true
        }
      }
    }
  }
}

Met REM preview kun je inspecteren wat een memory-cyclus zou doen voordat het echt naar disk schrijft — handig als je net begint met memoryCore en wilt zien wat je agent uit transcripts haalt.

Grounded REM backfill

Het dreaming-subsysteem kan historische dagnotities terugvoeren via een “grounded REM backfill”-lane. Dit betekent:

• Feiten uit oude dagnotities worden opnieuw geëvalueerd en gepromoveerd naar short-term memory als ze relevant zijn
• Een grounded scene lane biedt dagelijkse context-snapshots aan de dreaming-cyclus
• De dreaming diary UI in het Control Panel toont een timeline met backfill/reset knoppen en traceerbare samenvattingen

Dit is nuttig als je agent weken aan gesprekken heeft maar de oudere feiten “vergeten” was — de backfill haalt ze op zonder dat je handmatig hoeft te herindexeren.

Memory Wiki

memory-wiki is een nieuwe extension bovenop memory-core die je geheugen als een wiki/vault structureert (vergelijkbaar met Obsidian). Je krijgt:

• Wiki-pagina’s met backlinks tussen verwante notities
• Een ingest/compile/lint pipeline die transcripts opwerkt naar gestructureerde wiki-pagina’s
• Een agent lint-tool die ontbrekende provenance of dode links signaleert
• Een wiki apply mutation tool waarmee de agent zelf wiki-pagina’s kan aanpassen
• Dashboard rapport-pagina’s en wiki doctor diagnostics
• Een Obsidian-style CLI bridge zodat je je vault kan synchroniseren

openclaw plugins install memory-wiki
openclaw wiki doctor              # Diagnose
openclaw wiki ingest               # Verwerk nieuwe content

De wiki kan ook als shared search bridge dienen voor de gewone memory_search tool — agents kunnen wiki-pagina’s terugvinden zonder dat je een aparte tool nodig hebt.

Active Memory

De nieuwste memory-uitbreiding: een blocking memory sub-agent die vóór elke reply automatisch relevante herinneringen ophaalt en injecteert in de agent-context. Hierdoor voelt de agent “op de hoogte” zonder dat je zelf om memory_search hoeft te vragen.

{
  plugins: {
    entries: {
      "active-memory": {
        enabled: true,
        config: {
          enabled: true,
          agents: ["main"],
          allowedChatTypes: ["direct"],
          queryMode: "recent",       // of "semantic", "hybrid"
          promptStyle: "balanced",   // hoe agressief herinneringen injecteren
          timeoutMs: 15000,
          maxSummaryChars: 220,
          persistTranscripts: false,
          logging: true
        }
      }
    }
  }
}

Active Memory draait als bounded sidecar met timeout — als het te lang duurt, gaat de reply gewoon door zonder extra context. Configureerbaar per agent en chat-type (standaard alleen DMs, niet groeps). Docs: docs/concepts/active-memory.md.

Handige commando’s

openclaw memory status               # Index-statistieken
openclaw memory search "onderwerp"   # Zoek in geheugen
openclaw memory index                # Herindexeer alles
openclaw wiki doctor                 # (memory-wiki) sanity-check vault

Deel 7: Skills — wat de agent kan

Skills zijn de “vaardigheden” van de agent. Elke skill is een mapje met een SKILL.md bestand dat beschrijft wat de skill doet en wat hij nodig heeft.

Beschikbare skills bekijken

openclaw skills list              # Alle skills
openclaw skills list --eligible   # Alleen beschikbare skills
openclaw skills check             # Welke skills missen vereisten
openclaw skills info github       # Details van een specifieke skill

Hoe skills werken

Er zijn twee uitvoeringspaden:

1. Tool dispatch (snel, deterministisch) — de skill roept direct een ingebouwde tool aan:

/web_search "OpenClaw documentatie"

Geen AI nodig. De CLI parseert het commando en voert de tool direct uit.

2. Model invocation (flexibel, via agent) — de agent leest SKILL.md en voert de instructies uit:

/github "maak een issue voor de memory bug"

De agent leest de GitHub skill-instructies, denkt na over de stappen, en voert ze uit met de beschikbare tools (bash, read, write, etc.).

Claude Code in chat: claude-code-proxy

De claude-code-proxy skill maakt Claude Code conversationeel beschikbaar via je messaging-kanalen. Je kunt vanaf je telefoon (WhatsApp, Telegram, Discord) Claude Code laten coderen alsof je achter je laptop zit:

/claude-code-proxy "fix de regression in src/foo.ts en commit het"

De skill is budget-capped en channel-aware — output wordt geformatteerd voor het kanaal waarop je werkt en je hebt limieten zodat je niet per ongeluk een hele dag aan tokens verbrandt vanaf de bank.

Skill security

Skill-policy validatie wordt ook client-side afgedwongen, vóór de execution naar de server gaat. Probeer je een skill te draaien die niet door je policy is toegestaan, dan krijg je direct feedback in plaats van pas wanneer de server het blokkeert.

Skills installeren

Sommige skills vereisen externe programma’s:

# Controleer welke skills extra software nodig hebben
openclaw skills check --verbose

# Skills vanuit ClawHub (de publieke registry)
npx clawhub install <skill-naam>

Een eigen skill maken

mkdir -p ~/.openclaw/workspace/skills/mijn-skill

Maak SKILL.md:

---
name: mijn_skill
description: "Beschrijving van wat de skill doet"
metadata:
  openclaw:
    emoji: "🔧"
    requires:
      bins: ["curl"]
      env: ["MY_API_KEY"]
---

# Mijn Skill

Wanneer de gebruiker vraagt om [specifieke taak], doe dan:

1. Gebruik de web_fetch tool om data op te halen van [URL]
2. Verwerk het resultaat
3. Geef een samenvatting terug

De skill is direct beschikbaar (hot reload, 250ms debounce).

Skill configuratie

{
  skills: {
    entries: {
      "github": { enabled: true },
      "apple-notes": { enabled: true },
      "dangerous-skill": { enabled: false }
    }
  }
}

Deel 8: Meerdere kanalen tegelijk

OpenClaw kan verbonden zijn met 20+ kanalen tegelijk. Elk kanaal heeft zijn eigen adapter met eigen mogelijkheden.

Kanalen toevoegen

openclaw channels add --channel telegram --account alerts --token $TOKEN
openclaw channels add --channel discord --account work --token $DISCORD_TOKEN

Of interactief:

openclaw channels add

Kanaal-mogelijkheden

Slack ondersteunt Block Kit: agents kunnen rijke berichten sturen met knoppen, menus en secties. WeChat heeft een volwaardige integratie, gedocumenteerd in docs/channels/wechat.md.

Kanaal-specifieke opties

Een paar nieuwe knoppen die je per kanaal kunt instellen:

Slack — alleen op expliciete @mention reageren in threads

{
  channels: {
    slack: {
      thread: {
        requireExplicitMention: true
      }
    }
  }
}

Voorkomt dat de bot in een lopende thread doorblijft antwoorden zodra hij eenmaal getagged is. Iedere nieuwe vraag moet expliciet @bot bevatten.

WhatsApp — replies met quote

{
  channels: {
    whatsapp: {
      replyToMode: "quoted"   // of "auto" voor automatische detectie
    }
  }
}

Bot-replies tonen nu de originele bericht-quote, zoals een normale gebruiker dat ook zou doen.

Matrix — auto-join tijdens onboarding Tijdens openclaw onboard kan de Matrix-bot kamer-invitaties automatisch accepteren — handig als je veel rooms tegelijk wilt verbinden zonder ze één voor één handmatig te bevestigen.

Discord — kleine fixes onder de motorkap: gateway-verbindingen gebruiken nu ws voor compat, voice receive heeft een hardened error-recovery pad en lege gateway type-errors bevatten weer stack hints.

Inbound mention policy — gecentraliseerd

Alle kanalen delen één mention-policy: één centrale plek waar je regelt wanneer de Claw mag antwoorden in een groep. Pas je het in één kanaal aan, dan gelden de regels overal hetzelfde. Voorheen had elk kanaal zijn eigen regels, wat tot verwarrende verschillen leidde tussen Slack, Discord, Telegram, Matrix en WhatsApp.

Voice en meetings, wanneer chat niet genoeg is

Een Claw is op de kanalen die het ondersteunen niet beperkt tot tekst. Drie capabilities die werken waar het kanaal ze toelaat:

Voice-gesprekken. Browser, Discord en native nodes (iOS, macOS) delen één unified talk-systeem. Een gesprek dat in de browser start kan worden overgedragen aan iOS of Discord zonder dat het hapert. Voor Discord wordt audio rechtstreeks via ElevenLabs gestreamd, zonder aparte transcribe-stap.

Google Meet. Een Claw kan via een paired-node Chrome-transport meedoen aan Google Meet-meetings. Transcript-entries komen terug als artifacts in de sessie, zodat de Claw er na afloop nog over kan praten.

Telefonie (DTMF). Voor voice-calls ondersteunt OpenClaw keypad-tonen tijdens een gesprek. Essentieel wanneer de Claw zich door een IVR-menu moet werken om bijvoorbeeld terug te bellen.

Durable message lifecycle

Outbound berichten lopen door een gestructureerde levenscyclus: queued, sending, sent of failed. Channels tonen tijdens een lopende agent-run vaak een live-meelopend bericht (“progress draft”) zodat je kunt meekijken terwijl de Claw aan het werk is. Belangrijker: een netwerkstoring of een gateway-restart leidt niet meer tot verloren berichten, ook niet bij hoge volumes.

Multi-account (zelfde kanaal, verschillende bots)

{
  channels: {
    telegram: {
      accounts: {
        persoonlijk: {
          botToken: "token-1",
          dmPolicy: "pairing",
          allowFrom: ["+31612345678"]
        },
        alerts: {
          botToken: "token-2",
          dmPolicy: "open",
          allowFrom: ["*"]
        }
      },
      defaultAccount: "persoonlijk"
    }
  }
}

Status bekijken

openclaw channels status           # Overzicht
openclaw channels status --probe   # Diepere check (verbindingstest)
openclaw channels list             # Alle accounts

Deel 9: Multi-agent — meerdere persoonlijkheden

Dit is waar OpenClaw pas echt krachtig wordt. Je kunt meerdere agents draaien, elk met een eigen workspace, persoonlijkheid, model en kanaalverbindingen.

Agents aanmaken

openclaw agents add werk --workspace ~/.openclaw/workspace-werk
openclaw agents add thuis --workspace ~/.openclaw/workspace-thuis

Of in config:

{
  agents: {
    list: [
      { id: "thuis", default: true, workspace: "~/.openclaw/workspace-thuis" },
      { id: "werk", workspace: "~/.openclaw/workspace-werk" },
      { id: "ops", workspace: "~/.openclaw/workspace-ops" }
    ]
  }
}

Agents koppelen aan kanalen

Wie welk kanaal bedient:

{
  bindings: [
    { agentId: "thuis", match: { channel: "whatsapp" } },
    { agentId: "werk", match: { channel: "slack" } },
    { agentId: "ops", match: { channel: "telegram", accountId: "alerts" } }
  ]
}

Of via CLI:

openclaw agents bind --agent werk --bind slack
openclaw agents bind --agent ops --bind "telegram:alerts"

Routing-regels

De router bepaalt welke agent een bericht krijgt. Prioriteit:

1. Exacte peer match (Discord: role + guild + peer)
2. Thread-overerving (child volgt parent)
3. Guild + roles (Discord)
4. Account match
5. Kanaal match
6. Default agent

Elke agent heeft eigen workspace

~/.openclaw/workspace-thuis/     ← Eigen SOUL.md, MEMORY.md, skills
~/.openclaw/workspace-werk/      ← Ander model, andere persoonlijkheid
~/.openclaw/workspace-ops/       ← Minimale persoonlijkheid, focus op monitoring

Configureer per agent:

{
  agents: {
    list: [
      {
        id: "werk",
        workspace: "~/.openclaw/workspace-werk",
        model: { primary: "anthropic/claude-opus-4-6" },
        thinking: "high",
        heartbeat: {
          every: "1h",
          target: "slack",
          // heartbeat-sectie in system prompt aan/uit per agent
          includeSystemPromptSection: true
        },
        // complete system prompt overschrijven voor deze agent
        systemPromptOverride: "Je bent een ops-bot. Antwoord kort en in NL."
      }
    ]
  }
}

Per-agent system prompt overrides zijn handig als één agent fundamenteel anders moet praten dan de rest, bijvoorbeeld een ops-bot die alleen droge status-updates geeft. Voor lichte agents zonder heartbeat-loop bespaart heartbeat.includeSystemPromptSection: false ook aardig wat tokens.

Subagents (automatisch gespawnde agents)

De hoofdagent kan subagents spawnen voor parallelle taken:

Gebruiker: "Zoek informatie over X en Y tegelijk"
Agent: spawnt twee subagents, elk met een eigen sessie
Subagent 1: zoekt X → rapporteert terug
Subagent 2: zoekt Y → rapporteert terug
Agent: combineert resultaten

Subagents respecteren dieptelimieten:

Gesandboxte subagents hebben beperkte zichtbaarheid — ze kunnen alleen hun eigen sessie en door hen gespawnde sessies zien.

Commando’s

openclaw agents list                    # Alle agents
openclaw agents bindings                # Wie is waaraan gebonden
openclaw agents add <naam> --workspace <pad>
openclaw agents delete <naam> --force

Deel 10: Geplande taken met cron

De ingebouwde scheduler laat agents op geplande tijden draaien, resultaten afleveren via kanalen, en automatisch herstellen van fouten.

Eenmalige herinnering

openclaw cron add \
  --name "Herinnering" \
  --at "2026-04-01T09:00:00Z" \
  --session main \
  --system-event "Herinnering: documentatie reviewen" \
  --wake now \
  --delete-after-run

Relatieve tijd (over 20 minuten)

openclaw cron add \
  --name "Check" \
  --at "20m" \
  --session main \
  --system-event "Check de status van het deployment" \
  --wake now

Dagelijks terugkerend (geïsoleerde sessie)

openclaw cron add \
  --name "Ochtendstatus" \
  --cron "0 7 * * *" \
  --tz "Europe/Amsterdam" \
  --session isolated \
  --message "Vat de inbox en agenda voor vandaag samen." \
  --announce \
  --channel whatsapp \
  --to "+31612345678"

Wekelijks met zwaarder model

openclaw cron add \
  --name "Weekanalyse" \
  --cron "0 6 * * 1" \
  --tz "Europe/Amsterdam" \
  --session isolated \
  --message "Wekelijkse analyse van projectvoortgang." \
  --model "opus" \
  --thinking high \
  --announce

Cron in een bestaande sessie (--session-key)

Met --session-key laat je een cron-job in een specifieke bestaande sessie draaien. Handig als je een terugkerende taak wilt die binnen een doorlopende thread blijft, in plaats van iedere keer een nieuwe geïsoleerde sessie te beginnen:

openclaw cron add \
  --name "Project standup" \
  --cron "0 9 * * 1-5" \
  --tz "Europe/Amsterdam" \
  --session-key "agent:werk:slack:C12345" \
  --message "Vat de openstaande issues van project X samen."

De session key bepaalt welke conversatie de cron raakt — agent:<id>:<channel>:<peer>. De agent ziet hierdoor de hele context van die thread bij elke run, alsof jij zelf het bericht had gestuurd.

Cron vs heartbeat — wanneer wat?

Beheren

openclaw cron list                  # Alle jobs
openclaw cron status                # Status overzicht
openclaw cron runs --id <jobId>     # Geschiedenis
openclaw cron run <jobId>           # Handmatig uitvoeren
openclaw cron edit <jobId> --message "Nieuwe prompt"
openclaw cron remove <jobId>

Foutafhandeling

Bij transient errors (rate limits, timeouts, 5xx) probeert OpenClaw het opnieuw met exponentieel backoff:

Je kunt een failure alert instellen:

{
  cron: {
    failureAlert: {
      after: 3,
      channel: "telegram",
      to: "12345",
      cooldownMs: 3600000
    }
  }
}

Deel 11: Browser-automatisering

De agent kan webpagina’s bezoeken, formulieren invullen, screenshots maken en meer via Playwright.

Activeren

{
  browser: {
    enabled: true,
    defaultProfile: "openclaw"
  }
}

Handmatig testen

openclaw browser start
openclaw browser open https://example.com
openclaw browser screenshot
openclaw browser snapshot    # ARIA-toegankelijkheidsboom (tekst, niet pixels)

Wat de agent kan doen

De agent heeft browser-tools beschikbaar in skills:

Browser sessie selectie

De snelste manier om te kiezen welke browser de agent gebruikt:

De agent kiest automatisch het user profiel als dat beschikbaar is.

Tip: Gebruik browserSession: "user" wanneer de agent moet inloggen op diensten waar je al geauthenticeerd bent (Google, GitHub, interne tools). Gebruik "agent" voor schone scraping zonder je persoonlijke sessie te raken.

Profielen

{
  browser: {
    profiles: {
      werk: { cdpPort: 18801 },
      remote: { cdpUrl: "http://10.0.0.42:9222" }
    }
  }
}

Browser-profielen, hot-reloading

De browser server context ondersteunt profile hot-reloading: wijzigingen in profielen worden direct opgepakt zonder dat je de browser hoeft te herstarten. Tab-management is robuust, en strakkere guards rond interactieve acties voorkomen dat parallelle agents elkaar hinderen.

Voor Browserbase-gebruikers: directe WebSocket CDP-verbindingen worden nu ondersteund — meetbaar lagere latency dan HTTP polling:

{
  browser: {
    profiles: {
      cloud: {
        cdpUrl: "wss://connect.browserbase.com?apiKey=..."
      }
    }
  }
}

SSRF-bescherming

De browser weigert standaard navigatie naar private netwerken. Overschrijven (alleen als je weet wat je doet):

{
  browser: {
    ssrfPolicy: {
      dangerouslyAllowPrivateNetwork: true
    }
  }
}

Deel 12: Heartbeat — de proactieve agent

De heartbeat is een timer die de agent periodiek wakker maakt zonder dat je een bericht stuurt. Hiermee kan de agent geheugen onderhouden, herinneringen sturen en taken uitvoeren.

Activeren

{
  agents: {
    defaults: {
      heartbeat: {
        every: "30m",
        activeHours: {
          start: "08:00",
          end: "22:00",
          timezone: "Europe/Amsterdam"
        },
        target: "last",
        model: "anthropic/claude-sonnet-4-5",
        // heartbeat-sectie in system prompt aan/uit
        includeSystemPromptSection: true
      }
    }
  }
}

Wat de agent doet bij een heartbeat

De agent leest HEARTBEAT.md en voert de instructies uit. Typisch:

• Geheugen bijwerken
• Herinneringen checken
• Lopende taken reviewen

Als er niets te melden is, reageert de agent met HEARTBEAT_OK (onzichtbaar voor jou).

Commando’s

openclaw system heartbeat last      # Laatste heartbeat bekijken
openclaw system heartbeat enable    # Inschakelen
openclaw system heartbeat disable   # Uitschakelen

Deel 13: Docker-sandboxing

Een Claw kan code uitvoeren: bash-commando’s draaien, Python-scripts starten, bestanden aanpassen, een browser bedienen. Dat is precies wat hem nuttig maakt, en precies wat hem risicovol maakt. Een prompt-injection in een binnenkomende e-mail, een verkeerd ingestelde skill, een sub-agent die een onverwachte tool aanroept: in al die scenario’s wil je niet dat de uitvoering zomaar op je hostmachine landt.

Docker-sandboxing draait de tool-executie van een Claw in een geïsoleerde container. De container heeft standaard een read-only root filesystem, geen netwerkverbinding, alle Linux capabilities verwijderd, een geheugen-limiet en een PID-limiet. Een kwaadaardig commando dat je host zou kunnen beschadigen, kan dat binnen de sandbox simpelweg niet.

Wanneer kickt de sandbox in?

Niet bij elke turn. Een sandbox-start kost een paar seconden, dus OpenClaw probeert hem zo gericht mogelijk in te zetten. De mode-instelling bepaalt welke executies door de container gaan:

non-main is de pragmatische middenweg: jouw eigen interactie blijft direct, maar zodra de Claw zelf een subagent spawnt (vaak voor parallelle taken op onvoorspelbare data) gaat die in de container. Voor publieke bots die voor onbekende gebruikers werken, is all de juiste keuze.

Activeren

Eerst bouw je de Docker image die als basis dient. Het script in scripts/sandbox-setup.sh doet dat in één keer:

scripts/sandbox-setup.sh

Daarna configureer je de sandbox in openclaw.json:

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main",
        docker: {
          image: "node:22-slim",
          readOnlyRoot: true,
          network: "none",
          capDrop: ["ALL"],
          memory: "512m",
          pidsLimit: 100
        }
      }
    }
  }
}

memory en pidsLimit zijn zachte bovengrenzen, ze voorkomen dat een uit de hand gelopen tool je host opvreet. De waarden hierboven zijn ruim genoeg voor normale taken (bestanden lezen, korte scripts draaien, een API aanroepen) maar te krap voor zware data-processing. Verhoog ze als je werkelijk grote workloads aan je Claw geeft.

Wat is wel en niet bereikbaar vanuit de container?

De sandbox is niet een complete kopie van je systeem. Standaard:

• Workspace (de map met SOUL.md, MEMORY.md, skills): read-only mounted, zodat de Claw zijn eigen context kan lezen maar niet zijn persoonlijkheid kan herschrijven vanuit een tool.
• Filesystem buiten de workspace: niet bereikbaar. Een tool die ~/.ssh/id_rsa probeert te lezen, krijgt simpelweg “no such file”.
• Netwerk: standaard uit. Als een tool het web op moet (bijvoorbeeld de web_fetch tool), gaat het netwerkverkeer via een gecontroleerd pad in de gateway, niet via de container zelf.
• Geheim-materiaal (~/.openclaw/credentials/): niet gemount. De gateway stuurt alleen de hoogst-nodige tokens mee, en alleen wanneer de tool ze daadwerkelijk nodig heeft.

Het resultaat is dat een gecompromitteerde tool de Claw zelf niet kan kapen, en zeker je systeem niet.

Wat je kunt verwachten in gebruik

Drie zaken merk je in de praktijk:

1. Eerste cold start is langzamer. De image moet één keer geladen worden. Daarna draaien sandbox-aanroepen in honderden milliseconden.
2. Tools met netwerk-behoefte vragen om expliciete toestemming. Een tool die network: "none" overschrijft, vereist een instelling in de tool-config of een toestemming-prompt aan jou.
3. Logs verschijnen in openclaw logs zoals altijd, maar je ziet erbij dat een tool “in sandbox” liep, zodat je achteraf weet welke executie geïsoleerd is geweest.

Wanneer je het beter uit kunt laten

Op een persoonlijke laptop waar jij de enige gebruiker bent, je zelf alle skills hebt geschreven of geïnstalleerd en niemand anders je Claw kan aansturen, voegt de sandbox vooral overhead toe. mode: "off" is dan een redelijke keuze. Zodra je je Claw aan een publiek kanaal hangt (open WhatsApp-nummer, Discord-bot voor je community, web-form dat naar de gateway post) is non-main of all geen luxe meer maar de norm.

Deel 14: Hooks en automatisering

Een skill is iets dat de Claw zelf kan besluiten te gebruiken. Een hook is het omgekeerde: een stukje code dat zonder dat de Claw erom vraagt wordt uitgevoerd, omdat er iets in het systeem gebeurt. Een bericht komt binnen, een sessie start, een commando wordt aangeroepen, en daar wil je iets aan vasthangen. Loggen, transformeren, doorsturen, blokkeren.

Conceptueel: skills laten je de Claw nieuwe vaardigheden geven. Hooks laten je het systeem zelf gedrag geven dat onafhankelijk van de Claw bestaat. Een hook kan een bericht onderscheppen voordat de Claw het ooit ziet, of juist iets doen nadat de Claw klaar is met antwoorden.

Beschikbare events

Een hook maken

mkdir -p ~/.openclaw/hooks/mijn-hook

HOOK.md:

---
name: mijn-hook
description: "Log elk ontvangen bericht"
metadata:
  openclaw:
    events: ["message:received"]
---

handler.ts:

export default async function(event) {
  console.log(`Bericht van ${event.context.from}: ${event.context.content}`);
}

Gmail-integratie via hooks

openclaw webhooks gmail setup --account jouw-email@gmail.com --project gcp-project

{
  hooks: {
    enabled: true,
    mappings: [
      {
        match: { path: "gmail" },
        action: "agent",
        agentId: "main",
        deliver: true
      }
    ]
  }
}

Wake hooks zijn untrusted

Events die binnenkomen via wake-triggers (externe pings die de Claw wakker maken) worden gemarkeerd als untrusted. Dat betekent dat zo’n event niet stilletjes vertrouwde context kan injecteren in je Claw, alles uit een wake-event wordt behandeld als content van een onbekende afzender.

Waarom het uitmaakt: als je hooks gebruikt om externe systemen te laten “praten” met je agent (webhooks, Gmail Pub/Sub, Discord embeds), kan een aanvaller die een wake-trigger kan activeren niet meer doen alsof zijn payload van een vertrouwde bron komt. Tools die alleen voor trusted content open staan blijven dicht.

Hooks krijgen ook meer context mee (trigger, channelId) zodat je hook-implementaties context-aware beslissingen kunnen nemen over wat ze met een event doen.

Let op: als je een eigen hooks.internal.handlers config gebruikt, dat veld is alleen nog compat-input. De canonical config-key is hooks.internal.entries.

Deel 15: Native apps

Belangrijk om te weten: OpenClaw heeft een eigen iOS en Android app waarmee je rechtstreeks met je agent praat — zonder tussenkomst van WhatsApp/Telegram/Discord. Voor veel gebruikers is dit de primaire dagelijkse interface, niet een aanvulling. De messaging-channels zijn een uitbreiding wanneer je je agent in een gewone chat-app of een groep wilt hebben; de native apps zijn voor directe, persoonlijke conversaties met volledige device-integratie (camera, locatie, voice).

iOS app — volwaardige chat-client

De iOS app verbindt direct met je gateway (lokaal via Bonjour/mDNS of remote via Tailscale) en is een complete OpenClaw-client:

Communicatie:

• Chat met je agent — eigen chat-interface, geen WhatsApp/Telegram nodig
• Talk mode — push-to-talk én continuous voice-conversatie
• Voice wake — achtergrond wake-word detectie (“Hé Atlas…”)
• Apple Watch — chat, voice-input en exec-approvals op je pols
• Push notificaties voor agent-replies en exec-approvals, met approve/deny direct vanaf het lockscreen zonder de app te openen

Device-integratie (de agent kan dit gebruiken):

• Camera (foto + video opname op verzoek)
• Locatie (significant location monitor)
• Scherm (ReplayKit recording)
• Foto-library, kalender, contacten, herinneringen
• Motion data
• Widgets / Live Activities

Onder de motorkap:

• Dual gateway-sessies (één voor device-capabilities, één voor chat/voice)
• TLS certificate pinning (SHA256 fingerprint)
• 11Labs voice integratie met PCM/MP3 fallback
• Een authenticated background presence beacon zodat de gateway weet of de iOS-client actief is zonder dat de app open hoeft te zijn
• Talk handoff naar native nodes: een voice-gesprek dat in de browser begint kan worden overgedragen aan iOS zonder onderbreking

Verbinden:

openclaw qr   # genereert pairing QR; scan met de iOS-app

Gateway-verbindingsfoutmeldingen zijn duidelijk geformuleerd en de release-versioning is gepinned op CalVer (apps/ios/version.json).

Android app

Vergelijkbaar met iOS, Kotlin-gebaseerd (StateFlow + coroutines), verbindt direct via WebSocket. Chat-interface, talk mode, push notificaties. Het QR pairing-proces is robuust: stale setup-codes worden automatisch gewist bij nieuwe QR scans en stored device tokens hebben voorrang.

macOS app (menubar)

De macOS app is een menubar-applicatie met:

• Gateway-beheer (start/stop/herstart) — gateway draait als child proces van de app
• Chat-interface met je agent (canonical session keys, /new, /reset, /clear)
• Canvas windows voor web-content
• Talk mode (spraak), met experimentele MLX Talk provider voor lokale speech synthesis (geen API nodig, draait op Apple Silicon)
• Auto-update via Sparkle (de macOS update/restart handoff is robuust en voorkomt dat de app in een half-gestarte staat blijft hangen na een npm-update)
• Screen snapshots voor monitor preview: de macOS-app biedt een screen.snapshot node-command waarmee het Control Panel een live preview van je Mac-scherm kan tonen in de monitor-weergave

Welke interface wanneer?

Terminal UI (TUI)

openclaw tui

Volwaardige chat-interface in de terminal. Handig voor SSH-sessies.

Control Panel (web)

openclaw dashboard
# Of navigeer naar http://127.0.0.1:18789/

Web-interface gebouwd met Lit web components. Toont kanaalstatus, sessies, configuratie, logs.

Deel 16: CLI-referentie (de belangrijkste commando’s)

Dagelijks gebruik

openclaw status                    # Snelle health check
openclaw status --all              # Volledig overzicht
openclaw status --deep             # Met verbindingstests
openclaw doctor                    # Diagnose + fixes
openclaw doctor --fix              # Automatisch repareren
openclaw logs --follow             # Logs volgen (live)

Gateway

openclaw gateway start             # Starten
openclaw gateway stop              # Stoppen
openclaw gateway restart           # Herstarten
openclaw gateway run               # Op voorgrond draaien (debug)
openclaw gateway install           # Als service installeren
openclaw gateway status            # Service-status

Configuratie

openclaw config get <pad>          # Waarde opvragen
openclaw config set <pad> <waarde> # Waarde instellen
openclaw config validate           # Config valideren
openclaw configure                 # Interactieve wizard

Berichten

openclaw message send --target "+31612345678" --message "Hallo"
openclaw agent --message "Wat is de tijd?" --deliver
openclaw agent --message "code" --thinking high --local

Updaten

openclaw update                    # Naar nieuwste versie
openclaw update status             # Huidige versie + beschikbare update
openclaw update --channel beta     # Naar beta-kanaal

Deel 17: Configuratie-overzicht

Wat hot-reloadt en wat niet

Config-bestand structuur

{
  // Gateway: netwerk, auth, TLS
  gateway: { bind: "loopback", port: 18789, auth: { ... } },

  // Agents: modellen, workspace, heartbeat, sessies
  agents: { defaults: { ... }, list: [ ... ] },

  // Kanalen: WhatsApp, Telegram, Discord, etc.
  channels: { whatsapp: { ... }, telegram: { ... } },

  // Routing: welke agent bedient welk kanaal
  bindings: [ ... ],

  // Tools: welke tools de agent mag gebruiken
  tools: { profile: "messaging", deny: [ ... ] },

  // Skills: welke skills actief zijn
  skills: { entries: { ... } },

  // Cron: geplande taken
  cron: { enabled: true, ... },

  // Browser: automatisering
  browser: { enabled: true, ... },

  // Hooks: event-handlers
  hooks: { enabled: true, ... },

  // Sessies: scope, reset, threads, compaction checkpoints
  session: { dmScope: "per-channel-peer", ... },
  sessions: {
    compactionCheckpointOptions: { enabled: true, maxCheckpoints: 10 }
  },

  // Models: provider config, discovery
  models: { providers: { ... } },

  // Memory: vector search, embeddings
  // (in agents.defaults.memorySearch)

  // Environment variables
  env: { vars: { ... } },

  // $include: config opsplitsen in bestanden
  agents: { $include: "./agents.json5" },
}

Environment variabelen in config

{
  gateway: {
    auth: { token: "${OPENCLAW_GATEWAY_TOKEN}" }
  }
}

Escape letterlijke ${} met $${}.

Deel 18: Troubleshooting

Gateway start niet

lsof -i :18789              # Poort al in gebruik?
openclaw doctor              # Automatische diagnose
openclaw config validate     # Config-fouten?

Kanaal reageert niet

openclaw channels status --probe
openclaw logs --follow       # Zoek naar error-berichten

WhatsApp-koppeling verlopen

openclaw channels login      # Scan opnieuw de QR-code

Model niet gevonden

openclaw models list         # Welke modellen beschikbaar?
openclaw models status       # Auth-status per provider

Sessie loopt vast

openclaw gateway restart
# Of specifiek:
openclaw sessions            # Bekijk actieve sessies

Geheugen zoekt niet

openclaw memory status       # Is de index opgebouwd?
openclaw memory index        # Herindexeer

Alles faalt

openclaw doctor --fix        # Automatische reparatie
openclaw security audit --fix
openclaw gateway restart

Deel 19: Updaten en onderhoud

Bijwerken

openclaw update

Dit commando haalt de nieuwste versie op, installeert die, checkt config-compatibiliteit, en herstart de gateway.

Update-kanalen

openclaw update --channel beta
openclaw update status

Rollback

npm i -g openclaw@2026.3.11   # Pin naar specifieke versie
openclaw gateway restart

Backup

openclaw backup create

Deel 20: Verder leren

De vicboomer architectuurdocumenten

Deze documenten geven de technische diepgang achter alles wat je hierboven hebt geleerd:

Online bronnen

• Officiële docs: docs.openclaw.ai
• Security: docs.openclaw.ai/gateway/security
• Discord community: discord.gg/clawd

Snapshot van OpenClaw v2026.5.22, mei 2026. Actuele canonieke documentatie: docs.openclaw.ai.