Veelgestelde vragen

OpenClaw is een persoonlijke AI-assistent die je op je eigen apparaten draait. Hij antwoordt op de berichtenkanalen die je al gebruikt (WhatsApp, Telegram, Slack, Mattermost, Discord, Google Chat, Signal, iMessage, WebChat en gebundelde kanaalplugins zoals QQ Bot) en kan ook spraak + een live Canvas doen op ondersteunde platforms. De Gateway is het altijd actieve controlepaneel; de assistent is het product.

OpenClaw is niet "gewoon een Claude-wrapper." Het is een local-first controlepaneel waarmee je een krachtige assistent op je eigen hardware kunt draaien, bereikbaar vanuit de chatapps die je al gebruikt, met stateful sessies, geheugen en tools - zonder de controle over je workflows aan een gehoste SaaS over te dragen.

Hoogtepunten:

• Jouw apparaten, jouw data: draai de Gateway waar je wilt (Mac, Linux, VPS) en houd de workspace + sessiegeschiedenis lokaal.
• Echte kanalen, geen web-sandbox: WhatsApp/Telegram/Slack/Discord/Signal/iMessage/etc, plus mobiele spraak en Canvas op ondersteunde platforms.
• Model-agnostisch: gebruik Anthropic, OpenAI, MiniMax, OpenRouter, enz., met routing per agent en failover.
• Alleen-lokaal optie: draai lokale modellen zodat alle data op je apparaat kan blijven als je dat wilt.
• Multi-agent routing: afzonderlijke agents per kanaal, account of taak, elk met zijn eigen workspace en standaardinstellingen.
• Open source en aanpasbaar: inspecteer, breid uit en self-host zonder vendor lock-in.

Docs: Gateway, Kanalen, Multi-agent, Geheugen.

Goede eerste projecten:

• Bouw een website (WordPress, Shopify of een eenvoudige statische site).
• Prototype een mobiele app (outline, schermen, API-plan).
• Organiseer bestanden en mappen (opschonen, naamgeving, tagging).
• Verbind Gmail en automatiseer samenvattingen of follow-ups.

Het kan grote taken aan, maar werkt het best wanneer je ze in fasen opsplitst en subagents gebruikt voor parallel werk.

Dagelijkse winst ziet er meestal zo uit:

• Persoonlijke briefings: samenvattingen van inbox, agenda en nieuws dat voor jou belangrijk is.
• Onderzoek en concepten: snel onderzoek, samenvattingen en eerste concepten voor e-mails of docs.
• Herinneringen en follow-ups: cron- of Heartbeat-gestuurde nudges en checklists.
• Browserautomatisering: formulieren invullen, data verzamelen en webtaken herhalen.
• Coördinatie tussen apparaten: stuur een taak vanaf je telefoon, laat de Gateway die op een server uitvoeren en krijg het resultaat terug in chat.

Ja, voor onderzoek, kwalificatie en concepten. Het kan sites scannen, shortlists bouwen, prospects samenvatten en concepten schrijven voor outreach of advertentieteksten.

Houd bij outreach of advertentieruns een mens in de loop. Vermijd spam, volg lokale wetten en platformbeleid, en controleer alles voordat het wordt verzonden. Het veiligste patroon is om OpenClaw te laten opstellen en jou te laten goedkeuren.

Docs: Beveiliging.

OpenClaw is een persoonlijke assistent en coördinatielaag, geen vervanging voor een IDE. Gebruik Claude Code of Codex voor de snelste directe codeerloop binnen een repo. Gebruik OpenClaw wanneer je duurzaam geheugen, toegang tussen apparaten en toolorkestratie wilt.

Voordelen:

• Persistent geheugen + workspace over sessies heen
• Toegang op meerdere platforms (WhatsApp, Telegram, TUI, WebChat)
• Toolorkestratie (browser, bestanden, planning, hooks)
• Altijd actieve Gateway (draai op een VPS, communiceer vanaf overal)
• Nodes voor lokale browser/scherm/camera/exec

Showcase: https://openclaw.ai/showcase

Gebruik beheerde overrides in plaats van de repo-kopie te bewerken. Zet je wijzigingen in ~/.openclaw/skills/<name>/SKILL.md (of voeg een map toe via skills.load.extraDirs in ~/.openclaw/openclaw.json). De prioriteit is <workspace>/skills → <workspace>/.agents/skills → ~/.agents/skills → ~/.openclaw/skills → gebundeld → skills.load.extraDirs, dus beheerde overrides winnen nog steeds van gebundelde Skills zonder git aan te raken. Als je de Skill globaal geïnstalleerd nodig hebt maar alleen zichtbaar voor sommige agents, houd dan de gedeelde kopie in ~/.openclaw/skills en beheer zichtbaarheid met agents.defaults.skills en agents.list[].skills. Alleen wijzigingen die upstream waard zijn, horen in de repo te staan en als PR's uit te gaan.

Ja. Voeg extra mappen toe via skills.load.extraDirs in ~/.openclaw/openclaw.json (laagste prioriteit). De standaardprioriteit is <workspace>/skills → <workspace>/.agents/skills → ~/.agents/skills → ~/.openclaw/skills → gebundeld → skills.load.extraDirs. clawhub installeert standaard in ./skills, wat OpenClaw in de volgende sessie behandelt als <workspace>/skills. Als de Skill alleen zichtbaar moet zijn voor bepaalde agents, combineer dat dan met agents.defaults.skills of agents.list[].skills.

Tegenwoordig zijn de ondersteunde patronen:

• Cron-taken: geïsoleerde taken kunnen per taak een model-override instellen.
• Subagents: route taken naar afzonderlijke agents met verschillende standaardmodellen.
• On-demand wisselen: gebruik /model om op elk moment het model van de huidige sessie te wisselen.

Zie Cron-taken, Multi-agent routing en Slash-commando's.

Gebruik subagents voor lange of parallelle taken. Subagents draaien in hun eigen sessie, geven een samenvatting terug en houden je hoofdchat responsief.

Vraag je bot om "spawn a sub-agent for this task" of gebruik /subagents. Gebruik /status in chat om te zien wat de Gateway op dit moment doet (en of hij bezig is).

Tokentip: lange taken en subagents verbruiken allebei tokens. Als kosten een punt van zorg zijn, stel dan een goedkoper model in voor subagents via agents.defaults.subagents.model.

Docs: Subagents, Achtergrondtaken.

Gebruik threadbindingen. Je kunt een Discord-thread aan een subagent of sessiedoel binden zodat follow-upberichten in die thread op die gebonden sessie blijven.

Basisflow:

• Spawn met sessions_spawn met thread: true (en optioneel mode: "session" voor persistente follow-up).
• Of bind handmatig met /focus <target>.
• Gebruik /agents om de bindingsstatus te inspecteren.
• Gebruik /session idle <duration|off> en /session max-age <duration|off> om auto-unfocus te beheren.
• Gebruik /unfocus om de thread los te koppelen.

Vereiste configuratie:

• Globale standaardinstellingen: session.threadBindings.enabled, session.threadBindings.idleHours, session.threadBindings.maxAgeHours.
• Discord-overrides: channels.discord.threadBindings.enabled, channels.discord.threadBindings.idleHours, channels.discord.threadBindings.maxAgeHours.
• Automatisch binden bij spawn: channels.discord.threadBindings.spawnSessions staat standaard op true; zet dit op false om thread-gebonden sessiespawns uit te schakelen.

Docs: Subagents, Discord, Configuratiereferentie, Slash-commando's.

Controleer eerst de opgeloste requester-route:

• Levering van subagents in voltooiingsmodus geeft de voorkeur aan een gebonden thread of gespreksroute wanneer die bestaat.
• Als de voltooiingsoorsprong alleen een kanaal bevat, valt OpenClaw terug op de opgeslagen route van de requester-sessie (lastChannel / lastTo / lastAccountId) zodat directe levering nog steeds kan slagen.
• Als er geen gebonden route en geen bruikbare opgeslagen route bestaat, kan directe levering mislukken en valt het resultaat terug op levering via de wachtrij van de sessie in plaats van direct in chat te posten.
• Ongeldige of verouderde doelen kunnen nog steeds een wachtrijterugval of uiteindelijke leveringsfout afdwingen.
• Als het laatste zichtbare assistentantwoord van het kind exact het stille token NO_REPLY / no_reply is, of exact ANNOUNCE_SKIP, onderdrukt OpenClaw bewust de aankondiging in plaats van oudere voortgang te plaatsen.
• Als het kind na alleen toolaanroepen is getime-out, kan de aankondiging dat samenvouwen tot een korte samenvatting van gedeeltelijke voortgang in plaats van ruwe tooluitvoer opnieuw af te spelen.

Debug:

openclaw tasks show <runId-or-sessionKey>

Docs: Subagents, Achtergrondtaken, Sessietools.

Cron draait binnen het Gateway-proces. Als de Gateway niet continu draait, worden geplande taken niet uitgevoerd.

Checklist:

• Bevestig dat cron is ingeschakeld (cron.enabled) en OPENCLAW_SKIP_CRON niet is ingesteld.
• Controleer dat de Gateway 24/7 draait (geen slaapstand/herstarts).
• Verifieer tijdzone-instellingen voor de taak (--tz versus hosttijdzone).

Debug:

openclaw cron run <jobId>
openclaw cron runs --id <jobId> --limit 50

Docs: Cron-taken, Automatisering en taken.

Controleer eerst de aflevermodus:

• --no-deliver / delivery.mode: "none" betekent dat er geen fallbackverzending door de runner wordt verwacht.
• Een ontbrekend of ongeldig aankondigingsdoel (channel / to) betekent dat de runner uitgaande aflevering heeft overgeslagen.
• Authenticatiefouten voor kanalen (unauthorized, Forbidden) betekenen dat de runner probeerde af te leveren, maar dat de referenties dit blokkeerden.
• Een stil geïsoleerd resultaat (alleen NO_REPLY / no_reply) wordt behandeld als bewust niet-afleverbaar, dus onderdrukt de runner ook fallbackaflevering in de wachtrij.

Voor geïsoleerde cronjobs kan de agent nog steeds rechtstreeks verzenden met de message- tool wanneer er een chatroute beschikbaar is. --announce bepaalt alleen het fallbackpad van de runner voor definitieve tekst die de agent nog niet zelf heeft verzonden.

Debuggen:

openclaw cron runs --id <jobId> --limit 50
openclaw tasks show <runId-or-sessionKey>

Docs: Cronjobs, Achtergrondtaken.

Dat is meestal het live pad voor modelwisseling, geen dubbele planning.

Geïsoleerde Cron kan een runtime-modeloverdracht behouden en opnieuw proberen wanneer de actieve uitvoering LiveSessionModelSwitchError gooit. De nieuwe poging behoudt de gewisselde provider/het gewisselde model, en als de wissel een nieuwe override voor een auth-profiel bevatte, behoudt Cron die ook voordat opnieuw wordt geprobeerd.

Gerelateerde selectieregels:

• De modeloverride van de Gmail-hook wint als eerste wanneer van toepassing.
• Daarna model per taak.
• Daarna een opgeslagen modeloverride voor de cronsessie.
• Daarna de normale selectie van het agent-/standaardmodel.

De herhaallus is begrensd. Na de eerste poging plus 2 wisselherhalingen breekt Cron af in plaats van eeuwig te blijven herhalen.

Debuggen:

openclaw cron runs --id <jobId> --limit 50
openclaw tasks show <runId-or-sessionKey>

Docs: Cronjobs, cron CLI.

Gebruik native openclaw skills-opdrachten of plaats Skills in je werkruimte. De macOS Skills-UI is niet beschikbaar op Linux. Blader door Skills op https://clawhub.ai.

openclaw skills search "calendar"
openclaw skills search --limit 20
openclaw skills install <skill-slug>
openclaw skills install <skill-slug> --version <version>
openclaw skills install <skill-slug> --force
openclaw skills update --all
openclaw skills list --eligible
openclaw skills check

Native openclaw skills install schrijft naar de actieve werkruimte in de map skills/. Installeer de aparte clawhub CLI alleen als je je eigen Skills wilt publiceren of synchroniseren. Voor gedeelde installaties tussen agents plaats je de Skill onder ~/.openclaw/skills en gebruik je agents.defaults.skills of agents.list[].skills als je wilt beperken welke agents die kunnen zien.

Ja. Gebruik de Gateway-planner:

• Cronjobs voor geplande of terugkerende taken (blijven behouden na herstarts).
• Heartbeat voor periodieke controles van de "hoofdsessie".
• Geïsoleerde taken voor autonome agents die samenvattingen plaatsen of afleveren in chats.

Docs: Cronjobs, Automatisering en taken, Heartbeat.

Niet rechtstreeks. macOS-Skills worden beperkt door metadata.openclaw.os plus vereiste binaries, en Skills verschijnen alleen in de systeemprompt wanneer ze in aanmerking komen op de Gateway-host. Op Linux worden Skills die alleen voor darwin zijn (zoals apple-notes, apple-reminders, things-mac) niet geladen tenzij je de beperking overschrijft.

Je hebt drie ondersteunde patronen:

Optie A - voer de Gateway uit op een Mac (het eenvoudigst). Voer de Gateway uit waar de macOS-binaries bestaan en maak vervolgens verbinding vanaf Linux in externe modus of via Tailscale. De Skills laden normaal omdat de Gateway-host macOS is.

Optie B - gebruik een macOS-Node (geen SSH). Voer de Gateway uit op Linux, koppel een macOS-Node (menubalk-app) en stel Node-uitvoeropdrachten in op "Altijd vragen" of "Altijd toestaan" op de Mac. OpenClaw kan macOS-only Skills als geschikt behandelen wanneer de vereiste binaries op de Node bestaan. De agent voert die Skills uit via de nodes-tool. Als je "Altijd vragen" kiest, voegt goedkeuren van "Altijd toestaan" in de prompt die opdracht toe aan de allowlist.

Optie C - proxy macOS-binaries via SSH (geavanceerd). Houd de Gateway op Linux, maar laat de vereiste CLI-binaries oplossen naar SSH-wrappers die op een Mac draaien. Overschrijf daarna de Skill om Linux toe te staan, zodat die geschikt blijft.

1. Maak een SSH-wrapper voor de binary (voorbeeld: memo voor Apple Notes):

   #!/usr/bin/env bash
   set -euo pipefail
   exec ssh -T user@mac-host /opt/homebrew/bin/memo "$@"
   

2. Zet de wrapper op PATH op de Linux-host (bijvoorbeeld ~/bin/memo).

3. Overschrijf de Skill-metadata (werkruimte of ~/.openclaw/skills) om Linux toe te staan:

   ---
   name: apple-notes
   description: Manage Apple Notes via the memo CLI on macOS.
   metadata: { "openclaw": { "os": ["darwin", "linux"], "requires": { "bins": ["memo"] } } }
   ---
   

4. Start een nieuwe sessie zodat de momentopname van Skills wordt vernieuwd.

Niet ingebouwd op dit moment.

Opties:

• Aangepaste Skill / Plugin: het best voor betrouwbare API-toegang (Notion/HeyGen hebben beide API's).
• Browserautomatisering: werkt zonder code, maar is trager en kwetsbaarder.

Als je context per klant wilt behouden (agency-workflows), is een eenvoudig patroon:

• Eén Notion-pagina per klant (context + voorkeuren + actief werk).
• Vraag de agent om die pagina aan het begin van een sessie op te halen.

Als je een native integratie wilt, open dan een functieverzoek of bouw een Skill die op die API's is gericht.

Skills installeren:

openclaw skills install <skill-slug>
openclaw skills update --all

Native installaties komen terecht in de actieve werkruimte in de map skills/. Voor gedeelde Skills tussen agents plaats je ze in ~/.openclaw/skills/<name>/SKILL.md. Als slechts sommige agents een gedeelde installatie mogen zien, configureer dan agents.defaults.skills of agents.list[].skills. Sommige Skills verwachten binaries die via Homebrew zijn geïnstalleerd; op Linux betekent dat Linuxbrew (zie de Homebrew Linux-FAQ hierboven). Zie Skills, Skills-configuratie en ClawHub.

Gebruik het ingebouwde user-browserprofiel, dat koppelt via Chrome DevTools MCP:

openclaw browser --browser-profile user tabs
openclaw browser --browser-profile user snapshot

Als je een aangepaste naam wilt, maak dan een expliciet MCP-profiel:

openclaw browser create-profile --name chrome-live --driver existing-session
openclaw browser --browser-profile chrome-live tabs

Dit pad kan de lokale hostbrowser of een verbonden browser-Node gebruiken. Als de Gateway ergens anders draait, voer dan een Node-host uit op de browsermachine of gebruik in plaats daarvan externe CDP.

Huidige beperkingen van existing-session / user:

• acties worden aangestuurd door refs, niet door CSS-selectors
• uploads vereisen ref / inputRef en ondersteunen momenteel één bestand tegelijk
• responsebody, PDF-export, downloadonderschepping en batchacties hebben nog steeds een beheerde browser of een raw CDP-profiel nodig

Ja. Zie Sandboxing. Voor Docker-specifieke installatie (volledige Gateway in Docker of sandboximages), zie Docker.

De standaardimage is security-first en draait als de node-gebruiker, dus bevat die geen systeempakketten, Homebrew of gebundelde browsers. Voor een completere installatie:

• Bewaar /home/node persistent met OPENCLAW_HOME_VOLUME, zodat caches behouden blijven.
• Bak systeemafhankelijkheden in de image met OPENCLAW_DOCKER_APT_PACKAGES.
• Installeer Playwright-browsers via de gebundelde CLI: node /app/node_modules/playwright-core/cli.js install chromium
• Stel PLAYWRIGHT_BROWSERS_PATH in en zorg dat het pad persistent is.

Docs: Docker, Browser.

Ja - als je privéverkeer DM's is en je openbare verkeer groepen zijn.

Gebruik agents.defaults.sandbox.mode: "non-main" zodat groeps-/kanaalsessies (niet-hoofdsleutels) in de geconfigureerde sandboxbackend draaien, terwijl de hoofd-DM-sessie op de host blijft. Docker is de standaardbackend als je er geen kiest. Beperk daarna welke tools beschikbaar zijn in gesandboxte sessies via tools.sandbox.tools.

Installatiegids + voorbeeldconfiguratie: Groepen: persoonlijke DM's + openbare groepen

Belangrijke configuratiereferentie: Gateway-configuratie

Stel agents.defaults.sandbox.docker.binds in op ["host:path:mode"] (bijv. "/home/user/src:/src:ro"). Globale en per-agent binds worden samengevoegd; per-agent binds worden genegeerd wanneer scope: "shared" is. Gebruik :ro voor alles wat gevoelig is en onthoud dat binds de sandbox-bestandssysteemwanden omzeilen.

OpenClaw valideert bind-bronnen tegen zowel het genormaliseerde pad als het canonieke pad dat via de diepste bestaande ancestor wordt opgelost. Dat betekent dat ontsnappingen via symlink-parents nog steeds fail-closed zijn, zelfs wanneer het laatste padsegment nog niet bestaat, en dat controles op toegestane roots nog steeds gelden na symlink-resolutie.

Zie Sandboxing en Sandbox versus toolbeleid versus verhoogd voor voorbeelden en veiligheidsopmerkingen.

OpenClaw-geheugen bestaat gewoon uit Markdown-bestanden in de agentwerkruimte:

• Dagelijkse notities in memory/YYYY-MM-DD.md
• Gecureerde langetermijnnotities in MEMORY.md (alleen hoofd-/privésessies)

OpenClaw voert ook een stille geheugenflush vóór Compaction uit om het model eraan te herinneren duurzame notities te schrijven vóór automatische Compaction. Dit wordt alleen uitgevoerd wanneer de werkruimte schrijfbaar is (alleen-lezen sandboxes slaan dit over). Zie Geheugen.

Vraag de bot om het feit naar geheugen te schrijven. Langetermijnnotities horen thuis in MEMORY.md; kortetermijncontext gaat naar memory/YYYY-MM-DD.md.

Dit is nog steeds een gebied dat we verbeteren. Het helpt om het model eraan te herinneren herinneringen op te slaan; het weet wat het moet doen. Als het blijft vergeten, controleer dan of de Gateway bij elke uitvoering dezelfde werkruimte gebruikt.

Docs: Geheugen, Agentwerkruimte.

Geheugenbestanden staan op schijf en blijven bestaan totdat je ze verwijdert. De limiet is je opslag, niet het model. De sessiecontext wordt nog steeds beperkt door het contextvenster van het model, dus lange gesprekken kunnen worden gecompacteerd of afgekapt. Daarom bestaat geheugenzoekfunctie - die haalt alleen de relevante delen terug in context.

Docs: Geheugen, Context.

Alleen als je OpenAI-embeddings gebruikt. Codex OAuth dekt chat/completions en geeft geen toegang tot embeddings, dus inloggen met Codex (OAuth of de Codex CLI-login) helpt niet voor semantisch geheugenzoeken. OpenAI-embeddings hebben nog steeds een echte API-sleutel nodig (OPENAI_API_KEY of models.providers.openai.apiKey).

Als je niet expliciet een provider instelt, selecteert OpenClaw automatisch een provider wanneer het een API-sleutel kan vinden (auth-profielen, models.providers.*.apiKey of omgevingsvariabelen). Het geeft de voorkeur aan OpenAI als er een OpenAI-sleutel wordt gevonden, anders aan Gemini als er een Gemini-sleutel wordt gevonden, daarna Voyage en daarna Mistral. Als er geen externe sleutel beschikbaar is, blijft geheugenzoeken uitgeschakeld totdat je het configureert. Als je een lokaal modelpad hebt geconfigureerd en dat aanwezig is, geeft OpenClaw de voorkeur aan local. Ollama wordt ondersteund wanneer je expliciet memorySearch.provider = "ollama" instelt.

Als je liever lokaal blijft, stel dan memorySearch.provider = "local" in (en optioneel memorySearch.fallback = "none"). Als je Gemini-embeddings wilt, stel dan memorySearch.provider = "gemini" in en geef GEMINI_API_KEY op (of memorySearch.remote.apiKey). We ondersteunen OpenAI-, Gemini-, Voyage-, Mistral-, Ollama- of lokale embedding- modellen - zie Geheugen voor de installatiedetails.

Nee - de status van OpenClaw is lokaal, maar externe services zien nog steeds wat je naar ze verzendt.

• Standaard lokaal: sessies, geheugenbestanden, configuratie en workspace staan op de Gateway-host (~/.openclaw + je workspace-directory).
• Noodzakelijk extern: berichten die je naar modelproviders (Anthropic/OpenAI/etc.) verzendt, gaan naar hun API's, en chatplatformen (WhatsApp/Telegram/Slack/etc.) slaan berichtgegevens op hun servers op.
• Jij bepaalt de voetafdruk: lokale modellen gebruiken houdt prompts op je machine, maar kanaalverkeer loopt nog steeds via de servers van het kanaal.

Gerelateerd: Agent-workspace, Geheugen.

Alles staat onder $OPENCLAW_STATE_DIR (standaard: ~/.openclaw):

Legacy pad voor één agent: ~/.openclaw/agent/* (gemigreerd door openclaw doctor).

Je workspace (AGENTS.md, geheugenbestanden, Skills, enz.) staat apart en wordt geconfigureerd via agents.defaults.workspace (standaard: ~/.openclaw/workspace).

Deze bestanden staan in de agent-workspace, niet in ~/.openclaw.

• Workspace (per agent): AGENTS.md, SOUL.md, IDENTITY.md, USER.md, MEMORY.md, memory/YYYY-MM-DD.md, optioneel HEARTBEAT.md. Rootbestand memory.md in kleine letters is alleen legacy reparatie-invoer; openclaw doctor --fix kan het samenvoegen in MEMORY.md wanneer beide bestanden bestaan.
• Statusdirectory (~/.openclaw): configuratie, kanaal-/providerstatus, auth-profielen, sessies, logs en gedeelde Skills (~/.openclaw/skills).

De standaard-workspace is ~/.openclaw/workspace, configureerbaar via:

{
  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
}

Als de bot na een herstart "vergeet", controleer dan of de Gateway bij elke start dezelfde workspace gebruikt (en onthoud: externe modus gebruikt de workspace van de gateway-host, niet die van je lokale laptop).

Tip: als je duurzaam gedrag of een duurzame voorkeur wilt, vraag de bot dan om dit naar AGENTS.md of MEMORY.md te schrijven in plaats van te vertrouwen op chatgeschiedenis.

Zie Agent-workspace en Geheugen.

Zet je agent-workspace in een private git-repo en maak er ergens privé een back-up van (bijvoorbeeld GitHub private). Dit legt geheugen + AGENTS/SOUL/USER- bestanden vast en laat je later het "brein" van de assistent herstellen.

Commit niets onder ~/.openclaw (referenties, sessies, tokens of versleutelde geheime payloads). Als je volledig moet herstellen, maak dan afzonderlijk een back-up van zowel de workspace als de statusdirectory (zie de migratievraag hierboven).

Docs: Agent-workspace.

Zie de speciale handleiding: Verwijderen.

Ja. De workspace is de standaard cwd en geheugenanker, geen harde sandbox. Relatieve paden worden binnen de workspace opgelost, maar absolute paden kunnen andere hostlocaties benaderen tenzij sandboxing is ingeschakeld. Als je isolatie nodig hebt, gebruik dan agents.defaults.sandbox of sandboxinstellingen per agent. Als je wilt dat een repo de standaardwerkdirectory is, wijs dan de workspace van die agent naar de repo-root. De OpenClaw-repo is alleen broncode; houd de workspace apart tenzij je bewust wilt dat de agent erin werkt.

Voorbeeld (repo als standaard cwd):

{
  agents: {
    defaults: {
      workspace: "~/Projects/my-repo",
    },
  },
}

Sessiegegevens zijn eigendom van de gateway-host. Als je in externe modus werkt, staat de sessieopslag die voor jou belangrijk is op de externe machine, niet op je lokale laptop. Zie Sessiebeheer.

OpenClaw leest een optionele JSON5-configuratie uit $OPENCLAW_CONFIG_PATH (standaard: ~/.openclaw/openclaw.json):

$OPENCLAW_CONFIG_PATH

Als het bestand ontbreekt, gebruikt het redelijk veilige standaardwaarden (waaronder een standaard-workspace van ~/.openclaw/workspace).

Niet-loopback-binds vereisen een geldig gateway-authenticatiepad. In de praktijk betekent dit:

• authenticatie met gedeeld geheim: token of wachtwoord
• gateway.auth.mode: "trusted-proxy" achter een correct geconfigureerde identity-aware reverse proxy

{
  gateway: {
    bind: "lan",
    auth: {
      mode: "token",
      token: "replace-me",
    },
  },
}

Opmerkingen:

• gateway.remote.token / .password schakelen lokale gateway-authenticatie op zichzelf niet in.
• Lokale aanroeppaden kunnen gateway.remote.* alleen als fallback gebruiken wanneer gateway.auth.* niet is ingesteld.
• Stel voor wachtwoordauthenticatie in plaats daarvan gateway.auth.mode: "password" plus gateway.auth.password (of OPENCLAW_GATEWAY_PASSWORD) in.
• Als gateway.auth.token / gateway.auth.password expliciet via SecretRef is geconfigureerd en niet kan worden opgelost, faalt de oplossing gesloten (geen verhulling door externe fallback).
• Control UI-opstellingen met gedeeld geheim authenticeren via connect.params.auth.token of connect.params.auth.password (opgeslagen in app-/UI-instellingen). Modi met identiteit, zoals Tailscale Serve of trusted-proxy, gebruiken in plaats daarvan requestheaders. Zet geen gedeelde geheimen in URL's.
• Met gateway.auth.mode: "trusted-proxy" vereisen same-host local loopback reverse proxies expliciet gateway.auth.trustedProxy.allowLoopback = true en een loopback-item in gateway.trustedProxies.

OpenClaw dwingt standaard gateway-authenticatie af, inclusief loopback. In het normale standaardpad betekent dat tokenauthenticatie: als er geen expliciet authenticatiepad is geconfigureerd, wordt gateway-start opgelost naar tokenmodus en genereert het voor die start een runtime-only token, dus lokale WS-clients moeten authenticeren. Configureer gateway.auth.token, gateway.auth.password, OPENCLAW_GATEWAY_TOKEN of OPENCLAW_GATEWAY_PASSWORD expliciet wanneer clients een stabiel geheim over herstarts heen nodig hebben. Dit blokkeert andere lokale processen om de Gateway aan te roepen.

Als je een ander authenticatiepad verkiest, kun je expliciet de wachtwoordmodus kiezen (of, voor identity-aware reverse proxies, trusted-proxy). Als je echt open loopback wilt, stel dan expliciet gateway.auth.mode: "none" in je configuratie in. Doctor kan op elk moment een token voor je genereren: openclaw doctor --generate-gateway-token.

De Gateway bewaakt de configuratie en ondersteunt hot-reload:

• gateway.reload.mode: "hybrid" (standaard): veilige wijzigingen hot-toepassen, opnieuw opstarten voor kritieke wijzigingen
• hot, restart, off worden ook ondersteund

Stel cli.banner.taglineMode in de configuratie in:

{
  cli: {
    banner: {
      taglineMode: "off", // random | default | off
    },
  },
}

• off: verbergt taglinetekst maar behoudt de bannertitel-/versieregel.
• default: gebruikt elke keer All your chats, one OpenClaw..
• random: roterende grappige/seizoensgebonden taglines (standaardgedrag).
• Als je helemaal geen banner wilt, stel dan env OPENCLAW_HIDE_BANNER=1 in.

web_fetch werkt zonder API-sleutel. web_search hangt af van je geselecteerde provider:

• API-ondersteunde providers zoals Brave, Exa, Firecrawl, Gemini, Grok, Kimi, MiniMax Search, Perplexity en Tavily vereisen hun normale API-sleutelconfiguratie.
• Ollama Web Search is sleutelvrij, maar gebruikt je geconfigureerde Ollama-host en vereist ollama signin.
• DuckDuckGo is sleutelvrij, maar is een onofficiële HTML-gebaseerde integratie.
• SearXNG is sleutelvrij/self-hosted; configureer SEARXNG_BASE_URL of plugins.entries.searxng.config.webSearch.baseUrl.

Aanbevolen: voer openclaw configure --section web uit en kies een provider. Omgevingsalternatieven:

• Brave: BRAVE_API_KEY
• Exa: EXA_API_KEY
• Firecrawl: FIRECRAWL_API_KEY
• Gemini: GEMINI_API_KEY
• Grok: XAI_API_KEY
• Kimi: KIMI_API_KEY of MOONSHOT_API_KEY
• MiniMax Search: MINIMAX_CODE_PLAN_KEY, MINIMAX_CODING_API_KEY of MINIMAX_API_KEY
• Perplexity: PERPLEXITY_API_KEY of OPENROUTER_API_KEY
• SearXNG: SEARXNG_BASE_URL
• Tavily: TAVILY_API_KEY

{
  plugins: {
    entries: {
      brave: {
        config: {
          webSearch: {
            apiKey: "BRAVE_API_KEY_HERE",
          },
        },
      },
    },
    },
    tools: {
      web: {
        search: {
          enabled: true,
          provider: "brave",
          maxResults: 5,
        },
        fetch: {
          enabled: true,
          provider: "firecrawl", // optional; omit for auto-detect
        },
      },
    },
}

Providerspecifieke webzoekconfiguratie staat nu onder plugins.entries.<plugin>.config.webSearch.*. Verouderde providerpaden tools.web.search.* worden tijdelijk nog geladen voor compatibiliteit, maar ze moeten niet worden gebruikt voor nieuwe configuraties. Firecrawl-fallbackconfiguratie voor webophalen staat onder plugins.entries.firecrawl.config.webFetch.*.

Opmerkingen:

• Als je allowlists gebruikt, voeg dan web_search/web_fetch/x_search of group:web toe.
• web_fetch is standaard ingeschakeld (tenzij expliciet uitgeschakeld).
• Als tools.web.fetch.provider wordt weggelaten, detecteert OpenClaw automatisch de eerste gereedstaande fallbackprovider voor ophalen op basis van beschikbare inloggegevens. Op dit moment is de meegeleverde provider Firecrawl.
• Daemons lezen omgevingsvariabelen uit ~/.openclaw/.env (of uit de serviceomgeving).

Docs: Webtools.

config.apply vervangt de volledige configuratie. Als je een gedeeltelijk object verzendt, wordt al het andere verwijderd.

De huidige OpenClaw beschermt tegen veel onbedoelde overschrijvingen:

• Configuratieschrijfacties van OpenClaw valideren de volledige configuratie na de wijziging voordat er wordt geschreven.
• Ongeldige of destructieve schrijfacties van OpenClaw worden geweigerd en opgeslagen als openclaw.json.rejected.*.
• Als een directe bewerking het opstarten of hot reload kapotmaakt, faalt Gateway gesloten of slaat het herladen over; het herschrijft openclaw.json niet.
• openclaw doctor --fix is verantwoordelijk voor reparatie en kan de laatst bekende werkende configuratie herstellen terwijl het geweigerde bestand wordt opgeslagen als openclaw.json.clobbered.*.

Herstellen:

• Controleer openclaw logs --follow op Invalid config at, Config write rejected:, of config reload skipped (invalid config).
• Inspecteer de nieuwste openclaw.json.clobbered.* of openclaw.json.rejected.* naast de actieve configuratie.
• Voer openclaw config validate en openclaw doctor --fix uit.
• Kopieer alleen de bedoelde sleutels terug met openclaw config set of config.patch.
• Als je geen laatst bekende werkende configuratie of geweigerde payload hebt, herstel dan vanuit een back-up, of voer openclaw doctor opnieuw uit en configureer kanalen/modellen opnieuw.
• Als dit onverwacht was, dien dan een bugrapport in en voeg je laatst bekende configuratie of een eventuele back-up toe.
• Een lokale codeagent kan vaak een werkende configuratie reconstrueren uit logs of geschiedenis.

Voorkomen:

• Gebruik openclaw config set voor kleine wijzigingen.
• Gebruik openclaw configure voor interactieve bewerkingen.
• Gebruik eerst config.schema.lookup wanneer je niet zeker bent van een exact pad of de vorm van een veld; dit retourneert een oppervlakkig schemaknooppunt plus samenvattingen van directe kinderen om verder in te zoomen.
• Gebruik config.patch voor gedeeltelijke RPC-bewerkingen; gebruik config.apply alleen voor vervanging van de volledige configuratie.
• Als je de eigenaars-only tool gateway gebruikt vanuit een agentrun, blijft die schrijfacties naar tools.exec.ask / tools.exec.security weigeren (inclusief verouderde aliassen tools.bash.* die naar dezelfde beschermde exec-paden normaliseren).

Docs: Config, Configureren, Gateway-probleemoplossing, Doctor.

Het gangbare patroon is één Gateway (bijv. Raspberry Pi) plus nodes en agents:

• Gateway (centraal): beheert kanalen (Signal/WhatsApp), routering en sessies.
• Nodes (apparaten): Macs/iOS/Android verbinden als randapparaten en stellen lokale tools beschikbaar (system.run, canvas, camera).
• Agents (workers): afzonderlijke breinen/werkruimten voor speciale rollen (bijv. "Hetzner-ops", "Persoonlijke gegevens").
• Sub-agents: starten achtergrondwerk vanuit een hoofdagent wanneer je parallellisme wilt.
• TUI: verbind met de Gateway en wissel tussen agents/sessies.

Docs: Nodes, Externe toegang, Routering met meerdere agents, Sub-agents, TUI.

Ja. Het is een configuratieoptie:

{
  browser: { headless: true },
  agents: {
    defaults: {
      sandbox: { browser: { headless: true } },
    },
  },
}

De standaardwaarde is false (met venster). Headless triggert op sommige sites eerder anti-botcontroles. Zie Browser.

Headless gebruikt dezelfde Chromium-engine en werkt voor de meeste automatisering (formulieren, klikken, scrapen, aanmeldingen). De belangrijkste verschillen:

• Geen zichtbaar browservenster (gebruik schermafbeeldingen als je beeld nodig hebt).
• Sommige sites zijn strenger voor automatisering in headless-modus (CAPTCHA's, anti-bot). X/Twitter blokkeert bijvoorbeeld vaak headless-sessies.

Stel browser.executablePath in op je Brave-binary (of een andere Chromium-gebaseerde browser) en herstart de Gateway. Zie de volledige configuratievoorbeelden in Browser.

Telegram-berichten worden afgehandeld door de gateway. De gateway voert de agent uit en roept pas daarna nodes aan via de Gateway WebSocket wanneer een nodetool nodig is:

Telegram → Gateway → Agent → node.* → Node → Gateway → Telegram

Nodes zien geen binnenkomend providerverkeer; ze ontvangen alleen node-RPC-aanroepen.

Kort antwoord: koppel je computer als node. De Gateway draait elders, maar kan node.*-tools (scherm, camera, systeem) op je lokale machine aanroepen via de Gateway WebSocket.

Typische installatie:

1. Voer de Gateway uit op de altijd-aan host (VPS/thuisserver).

2. Zet de Gateway-host en je computer op hetzelfde tailnet.

3. Zorg dat de Gateway WS bereikbaar is (tailnet-binding of SSH-tunnel).

4. Open de macOS-app lokaal en verbind in de modus Extern via SSH (of direct tailnet) zodat deze zich als node kan registreren.

5. Keur de node goed op de Gateway:

   openclaw devices list
   openclaw devices approve <requestId>
   

Er is geen aparte TCP-bridge nodig; nodes verbinden via de Gateway WebSocket.

Beveiligingsherinnering: het koppelen van een macOS-node staat system.run toe op die machine. Koppel alleen apparaten die je vertrouwt, en bekijk Beveiliging.

Docs: Nodes, Gateway-protocol, macOS externe modus, Beveiliging.

Controleer de basis:

• Gateway draait: openclaw gateway status
• Gateway-status: openclaw status
• Kanaalstatus: openclaw channels status

Verifieer daarna authenticatie en routering:

• Als je Tailscale Serve gebruikt, zorg dan dat gateway.auth.allowTailscale correct is ingesteld.
• Als je via een SSH-tunnel verbindt, bevestig dan dat de lokale tunnel actief is en naar de juiste poort wijst.
• Bevestig dat je allowlists (DM of groep) je account bevatten.

Docs: Tailscale, Externe toegang, Kanalen.

Ja. Er is geen ingebouwde "bot-naar-bot"-bridge, maar je kunt dit op een paar betrouwbare manieren opzetten:

Eenvoudigst: gebruik een normaal chatkanaal waartoe beide bots toegang hebben (Telegram/Slack/WhatsApp). Laat Bot A een bericht naar Bot B sturen, en laat Bot B daarna zoals gebruikelijk antwoorden.

CLI-bridge (generiek): voer een script uit dat de andere Gateway aanroept met openclaw agent --message ... --deliver, gericht op een chat waar de andere bot luistert. Als één bot op een externe VPS staat, wijs je CLI dan naar die externe Gateway via SSH/Tailscale (zie Externe toegang).

Voorbeeldpatroon (uitvoeren vanaf een machine die de doel-Gateway kan bereiken):

openclaw agent --message "Hello from local bot" --deliver --channel telegram --reply-to <chat-id>

Tip: voeg een vangrail toe zodat de twee bots niet eindeloos blijven rondlussen (alleen vermeldingen, kanaal- allowlists, of een regel "niet antwoorden op botberichten").

Docs: Externe toegang, Agent-CLI, Agent verzenden.

Nee. Eén Gateway kan meerdere agents hosten, elk met een eigen werkruimte, modelstandaarden en routering. Dat is de normale opzet en die is veel goedkoper en eenvoudiger dan één VPS per agent draaien.

Gebruik aparte VPS'en alleen wanneer je harde isolatie nodig hebt (beveiligingsgrenzen) of zeer verschillende configuraties die je niet wilt delen. Houd anders één Gateway aan en gebruik meerdere agents of sub-agents.

Ja - nodes zijn de eersteklas manier om je laptop te bereiken vanaf een externe Gateway, en ze bieden meer dan shelltoegang. De Gateway draait op macOS/Linux (Windows via WSL2) en is lichtgewicht (een kleine VPS of Raspberry Pi-klasse machine is voldoende; 4 GB RAM is ruim genoeg), dus een gangbare opzet is een altijd-aan host plus je laptop als node.

• Geen inkomende SSH vereist. Nodes verbinden uitgaand met de Gateway WebSocket en gebruiken apparaatkoppeling.
• Veiligere uitvoeringscontroles. system.run wordt op die laptop afgeschermd door node-allowlists/goedkeuringen.
• Meer apparaattools. Nodes stellen naast system.run ook canvas, camera en screen beschikbaar.
• Lokale browserautomatisering. Houd de Gateway op een VPS, maar voer Chrome lokaal uit via een nodehost op de laptop, of koppel aan lokale Chrome op de host via Chrome MCP.

SSH is prima voor ad-hoc shelltoegang, maar nodes zijn eenvoudiger voor doorlopende agentworkflows en apparaatautomatisering.

Docs: Nodes, Nodes-CLI, Browser.

Nee. Er mag slechts één gateway per host draaien, tenzij je bewust geïsoleerde profielen draait (zie Meerdere gateways). Nodes zijn randapparaten die verbinden met de gateway (iOS/Android-nodes, of macOS-"nodemodus" in de menubalkapp). Zie Node host CLI voor headless node- hosts en CLI-besturing.

Een volledige herstart is vereist voor wijzigingen aan gateway, discovery en gehoste pluginoppervlakken.

Ja.

• config.schema.lookup: inspecteer één config-subboom met zijn oppervlakkige schemaknooppunt, overeenkomende UI-hint en samenvattingen van directe kinderen voordat je schrijft
• config.get: haal de huidige snapshot + hash op
• config.patch: veilige gedeeltelijke update (aanbevolen voor de meeste RPC-bewerkingen); hot-reloadt wanneer mogelijk en herstart wanneer vereist
• config.apply: valideer + vervang de volledige config; hot-reloadt wanneer mogelijk en herstart wanneer vereist
• De runtime-tool gateway voor alleen de eigenaar weigert nog steeds tools.exec.ask / tools.exec.security te herschrijven; legacy tools.bash.*-aliassen normaliseren naar dezelfde beschermde exec-paden

{
  agents: { defaults: { workspace: "~/.openclaw/workspace" } },
  channels: { whatsapp: { allowFrom: ["+15555550123"] } },
}

Hiermee stel je je workspace in en beperk je wie de bot kan activeren.

Minimale stappen:

1. Installeer + log in op de VPS

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

2. Installeer + log in op je Mac

   • Gebruik de Tailscale-app en meld je aan bij dezelfde tailnet.

3. Schakel MagicDNS in (aanbevolen)

   • Schakel MagicDNS in de Tailscale-beheerconsole in zodat de VPS een stabiele naam heeft.

4. Gebruik de tailnet-hostnaam

   • SSH: ssh [email protected]
   • Gateway WS: ws://your-vps.tailnet-xxxx.ts.net:18789

Als je de Control UI zonder SSH wilt, gebruik dan Tailscale Serve op de VPS:

openclaw gateway --tailscale serve

Hierdoor blijft de Gateway aan loopback gebonden en wordt HTTPS via Tailscale beschikbaar gemaakt. Zie Tailscale.

Serve stelt de Gateway Control UI + WS beschikbaar. Nodes verbinden via hetzelfde Gateway WS-eindpunt.

Aanbevolen setup:

1. Zorg dat de VPS + Mac op dezelfde tailnet zitten.

2. Gebruik de macOS-app in Remote-modus (SSH-doel kan de tailnet-hostnaam zijn). De app tunnelt de Gateway-poort en verbindt als Node.

3. Keur de Node goed op de gateway:

   openclaw devices list
   openclaw devices approve <requestId>
   

Docs: Gateway-protocol, Detectie, macOS Remote-modus.

Als je alleen lokale tools (scherm/camera/exec) op de tweede laptop nodig hebt, voeg die dan toe als Node. Zo behoud je één Gateway en voorkom je dubbele config. Lokale Node-tools zijn momenteel alleen voor macOS, maar we zijn van plan ze uit te breiden naar andere besturingssystemen.

Installeer alleen een tweede Gateway wanneer je strikte isolatie of twee volledig afzonderlijke bots nodig hebt.

Docs: Nodes, Nodes-CLI, Meerdere gateways.

OpenClaw leest env-vars uit het bovenliggende proces (shell, launchd/systemd, CI, enz.) en laadt daarnaast:

• .env uit de huidige werkmap
• een globale fallback-.env uit ~/.openclaw/.env (ook bekend als $OPENCLAW_STATE_DIR/.env)

Geen van beide .env-bestanden overschrijft bestaande env-vars.

Je kunt ook inline env-vars in config definiëren (alleen toegepast als ze ontbreken in de proces-env):

{
  env: {
    OPENROUTER_API_KEY: "sk-or-...",
    vars: { GROQ_API_KEY: "gsk-..." },
  },
}

Zie /environment voor volledige prioriteit en bronnen.

Twee veelvoorkomende oplossingen:

1. Zet de ontbrekende sleutels in ~/.openclaw/.env, zodat ze worden opgepikt zelfs wanneer de service je shell-env niet erft.
2. Schakel shell-import in (optioneel gemak):

{
  env: {
    shellEnv: {
      enabled: true,
      timeoutMs: 15000,
    },
  },
}

Dit voert je login-shell uit en importeert alleen ontbrekende verwachte sleutels (overschrijft nooit). Equivalenten voor env-vars: OPENCLAW_LOAD_SHELL_ENV=1, OPENCLAW_SHELL_ENV_TIMEOUT_MS=15000.

openclaw models status rapporteert of shell-env-import is ingeschakeld. "Shell env: off" betekent niet dat je env-vars ontbreken - het betekent alleen dat OpenClaw je login-shell niet automatisch laadt.

Als de Gateway als service draait (launchd/systemd), erft die je shell- omgeving niet. Los dit op door een van deze dingen te doen:

1. Zet de token in ~/.openclaw/.env:

   COPILOT_GITHUB_TOKEN=...
   

2. Of schakel shell-import in (env.shellEnv.enabled: true).

3. Of voeg die toe aan het env-blok in je config (alleen toegepast als die ontbreekt).

Herstart daarna de gateway en controleer opnieuw:

openclaw models status

Copilot-tokens worden gelezen uit COPILOT_GITHUB_TOKEN (ook GH_TOKEN / GITHUB_TOKEN). Zie /concepts/model-providers en /environment.

Stuur /new of /reset als een zelfstandig bericht. Zie Sessiebeheer.

Sessies kunnen verlopen na session.idleMinutes, maar dit is standaard uitgeschakeld (standaard 0). Stel dit in op een positieve waarde om verlopen bij inactiviteit in te schakelen. Wanneer dit is ingeschakeld, start het volgende bericht na de inactieve periode een nieuwe sessie-id voor die chatsleutel. Dit verwijdert geen transcripts - het start alleen een nieuwe sessie.

{
  session: {
    idleMinutes: 240,
  },
}

Ja, via multi-agentrouting en sub-agents. Je kunt één coördinator- agent en meerdere worker-agents maken met hun eigen workspaces en modellen.

Dat gezegd hebbende, dit kun je het best zien als een leuk experiment. Het verbruikt veel tokens en is vaak minder efficiënt dan één bot met afzonderlijke sessies gebruiken. Het typische model dat wij voor ons zien is één bot waarmee je praat, met verschillende sessies voor parallel werk. Die bot kan indien nodig ook sub-agents starten.

Docs: Multi-agentrouting, Sub-agents, Agents-CLI.

Sessiecontext wordt beperkt door het modelvenster. Lange chats, grote tooluitvoer of veel bestanden kunnen Compaction of afkapping veroorzaken.

Dit helpt:

• Vraag de bot om de huidige staat samen te vatten en naar een bestand te schrijven.
• Gebruik /compact vóór lange taken, en /new wanneer je van onderwerp wisselt.
• Houd belangrijke context in de workspace en vraag de bot om die opnieuw te lezen.
• Gebruik sub-agents voor lang of parallel werk, zodat de hoofdchat kleiner blijft.
• Kies een model met een groter contextvenster als dit vaak gebeurt.

Gebruik de resetopdracht:

openclaw reset

Niet-interactieve volledige reset:

openclaw reset --scope full --yes --non-interactive

Voer daarna de setup opnieuw uit:

openclaw onboard --install-daemon

Opmerkingen:

• Onboarding biedt ook Reset als er een bestaande config wordt gevonden. Zie Onboarding (CLI).
• Als je profielen hebt gebruikt (--profile / OPENCLAW_PROFILE), reset dan elke state-dir (standaardwaarden zijn ~/.openclaw-<profile>).
• Dev-reset: openclaw gateway --dev --reset (alleen dev; wist dev-config + credentials + sessies + workspace).

Gebruik een van deze opties:

• Compact (behoudt het gesprek maar vat oudere beurten samen):

  /compact
  

  of /compact <instructions> om de samenvatting te sturen.

• Reset (nieuwe sessie-id voor dezelfde chatsleutel):

  /new
  /reset
  

Als dit blijft gebeuren:

• Schakel sessie-opschoning (agents.defaults.contextPruning) in of stem die af om oude tooluitvoer in te korten.
• Gebruik een model met een groter contextvenster.

Docs: Compaction, Sessie-opschoning, Sessiebeheer.

Dit is een providervalidatiefout: het model heeft een tool_use-blok zonder de vereiste input uitgezonden. Dit betekent meestal dat de sessiegeschiedenis verouderd of beschadigd is (vaak na lange threads of een tool-/schemawijziging).

Oplossing: start een nieuwe sessie met /new (zelfstandig bericht).

Heartbeats draaien standaard elke 30m (1h bij gebruik van OAuth-auth). Stem ze af of schakel ze uit:

{
  agents: {
    defaults: {
      heartbeat: {
        every: "2h", // or "0m" to disable
      },
    },
  },
}

Als HEARTBEAT.md bestaat maar in feite leeg is (alleen lege regels en markdown- koppen zoals # Heading), slaat OpenClaw de heartbeat-run over om API-calls te besparen. Als het bestand ontbreekt, draait de heartbeat nog steeds en beslist het model wat te doen.

Overrides per agent gebruiken agents.list[].heartbeat. Docs: Heartbeat.

Nee. OpenClaw draait op je eigen account, dus als jij in de groep zit, kan OpenClaw die zien. Standaard worden groepsantwoorden geblokkeerd totdat je afzenders toestaat (groupPolicy: "allowlist").

Als je wilt dat alleen jij groepsantwoorden kunt activeren:

{
  channels: {
    whatsapp: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15551234567"],
    },
  },
}

Optie 1 (snelst): volg logs en stuur een testbericht in de groep:

openclaw logs --follow --json

Zoek naar chatId (of from) dat eindigt op @g.us, zoals: [email protected].

Optie 2 (als al geconfigureerd/toegestaan): lijst groepen uit config op:

openclaw directory groups list --channel whatsapp

Docs: WhatsApp, Directory, Logs.

Twee veelvoorkomende oorzaken:

• Vermeldingsgating staat aan (standaard). Je moet de bot @mentionen (of overeenkomen met mentionPatterns).
• Je hebt channels.whatsapp.groups geconfigureerd zonder "*" en de groep staat niet op de allowlist.

Zie Groepen en Groepsberichten.

Directe chats worden standaard samengevoegd tot de hoofdsessie. Groepen/kanalen hebben hun eigen sessiesleutels, en Telegram-onderwerpen / Discord-threads zijn afzonderlijke sessies. Zie Groepen en Groepsberichten.

Geen harde limieten. Tientallen (zelfs honderden) zijn prima, maar let op:

• Schijfgroei: sessies + transcripties staan onder ~/.openclaw/agents/<agentId>/sessions/.
• Tokenkosten: meer agents betekent meer gelijktijdig modelgebruik.
• Operationele overhead: auth-profielen, workspaces en kanaalroutering per agent.

Tips:

• Houd één actieve workspace per agent (agents.defaults.workspace).
• Schoon oude sessies op (verwijder JSONL- of store-vermeldingen) als de schijf groeit.
• Gebruik openclaw doctor om verdwaalde workspaces en profielmismatches te vinden.

Ja. Gebruik Multi-Agent-routering om meerdere geïsoleerde agents uit te voeren en inkomende berichten te routeren op kanaal/account/peer. Slack wordt als kanaal ondersteund en kan aan specifieke agents worden gekoppeld.

Browsertoegang is krachtig, maar niet "alles kunnen doen wat een mens kan" - antibot, CAPTCHAs en MFA kunnen automatisering nog steeds blokkeren. Gebruik voor de betrouwbaarste browserbesturing lokale Chrome MCP op de host, of gebruik CDP op de machine waarop de browser daadwerkelijk draait.

Aanbevolen setup:

• Altijd-aan Gateway-host (VPS/Mac mini).
• Eén agent per rol (koppelingen).
• Slack-kanaal/kanalen gekoppeld aan die agents.
• Lokale browser via Chrome MCP of een node wanneer nodig.

Docs: Multi-Agent-routering, Slack, Browser, Nodes.

gateway.port beheert de enkele gemultiplexte poort voor WebSocket + HTTP (Control UI, hooks, enz.).

Prioriteit:

--port > OPENCLAW_GATEWAY_PORT > gateway.port > default 18789

Omdat "running" de weergave van de supervisor is (launchd/systemd/schtasks). De connectiviteitsprobe is de CLI die daadwerkelijk verbinding maakt met de gateway-WebSocket.

Gebruik openclaw gateway status en vertrouw op deze regels:

• Probe target: (de URL die de probe daadwerkelijk gebruikte)
• Listening: (wat daadwerkelijk op de poort is gebonden)
• Last gateway error: (veelvoorkomende hoofdoorzaak wanneer het proces actief is maar de poort niet luistert)

Je bewerkt één configuratiebestand terwijl de service een ander bestand gebruikt (vaak een mismatch met --profile / OPENCLAW_STATE_DIR).

Oplossing:

openclaw gateway install --force

Voer dat uit vanuit hetzelfde --profile / dezelfde omgeving die je door de service wilt laten gebruiken.

OpenClaw dwingt een runtime-lock af door de WebSocket-listener direct bij het opstarten te binden (standaard ws://127.0.0.1:18789). Als het binden mislukt met EADDRINUSE, wordt GatewayLockError gegooid om aan te geven dat er al een andere instantie luistert.

Oplossing: stop de andere instantie, maak de poort vrij, of voer uit met openclaw gateway --port <port>.

Stel gateway.mode: "remote" in en verwijs naar een externe WebSocket-URL, optioneel met externe referenties via een gedeeld geheim:

{
  gateway: {
    mode: "remote",
    remote: {
      url: "ws://gateway.tailnet:18789",
      token: "your-token",
      password: "your-password",
    },
  },
}

Opmerkingen:

• openclaw gateway start alleen wanneer gateway.mode local is (of wanneer je de override-vlag meegeeft).
• De macOS-app bewaakt het configuratiebestand en wisselt live van modus wanneer deze waarden veranderen.
• gateway.remote.token / .password zijn alleen client-side externe referenties; ze schakelen op zichzelf geen lokale gateway-auth in.

Je gateway-authpad en de auth-methode van de UI komen niet overeen.

Feiten (uit code):

• De Control UI bewaart de token in sessionStorage voor de huidige browsertabsessie en geselecteerde gateway-URL, zodat verversen in hetzelfde tabblad blijft werken zonder langdurige localStorage-tokenpersistentie te herstellen.
• Bij AUTH_TOKEN_MISMATCH kunnen vertrouwde clients één begrensde retry proberen met een gecachte apparaattoken wanneer de gateway retry-hints teruggeeft (canRetryWithDeviceToken=true, recommendedNextStep=retry_with_device_token).
• Die retry met gecachte token hergebruikt nu de gecachte goedgekeurde scopes die met de apparaattoken zijn opgeslagen. Callers met expliciete deviceToken / expliciete scopes behouden nog steeds hun aangevraagde scopeset in plaats van gecachte scopes te erven.
• Buiten dat retry-pad is de auth-prioriteit bij verbinden eerst expliciete gedeelde token/wachtwoord, daarna expliciete deviceToken, daarna opgeslagen apparaattoken, daarna bootstrap-token.
• Scopecontroles voor bootstrap-tokens hebben een rolprefix. De ingebouwde bootstrap-operator-allowlist voldoet alleen aan operatorverzoeken; node- of andere niet-operatorrollen hebben nog steeds scopes nodig onder hun eigen rolprefix.

Oplossing:

• Snelst: openclaw dashboard (print + kopieert de dashboard-URL, probeert te openen; toont SSH-hint als headless).
• Als je nog geen token hebt: openclaw doctor --generate-gateway-token.
• Als het extern is, tunnel eerst: ssh -N -L 18789:127.0.0.1:18789 user@host en open daarna http://127.0.0.1:18789/.
• Modus met gedeeld geheim: stel gateway.auth.token / OPENCLAW_GATEWAY_TOKEN of gateway.auth.password / OPENCLAW_GATEWAY_PASSWORD in, en plak daarna het overeenkomende geheim in de Control UI-instellingen.
• Tailscale Serve-modus: zorg dat gateway.auth.allowTailscale is ingeschakeld en dat je de Serve-URL opent, niet een ruwe loopback-/tailnet-URL die Tailscale-identiteitsheaders omzeilt.
• Vertrouwde-proxy-modus: zorg dat je via de geconfigureerde identity-aware proxy binnenkomt, niet via een ruwe gateway-URL. local loopback-proxy's op dezelfde host hebben ook gateway.auth.trustedProxy.allowLoopback = true nodig.
• Als de mismatch na de ene retry blijft bestaan, roteer/keur de gekoppelde apparaattoken opnieuw goed:
  • openclaw devices list
  • openclaw devices rotate --device <id> --role operator
• Als die roteer-aanroep zegt dat deze is geweigerd, controleer twee dingen:
  • gekoppelde-apparaatsessies kunnen alleen hun eigen apparaat roteren, tenzij ze ook operator.admin hebben
  • expliciete --scope-waarden mogen de huidige operatorscopes van de caller niet overschrijden
• Nog steeds vast? Voer openclaw status --all uit en volg Probleemoplossing. Zie Dashboard voor auth-details.

tailnet-bind kiest een Tailscale-IP uit je netwerkinterfaces (100.64.0.0/10). Als de machine niet op Tailscale zit (of de interface down is), is er niets om aan te binden.

Oplossing:

• Start Tailscale op die host (zodat deze een 100.x-adres heeft), of
• Schakel over naar gateway.bind: "loopback" / "lan".

Opmerking: tailnet is expliciet. auto geeft de voorkeur aan loopback; gebruik gateway.bind: "tailnet" wanneer je een bind wilt die alleen voor tailnet geldt.

Meestal niet - één Gateway kan meerdere berichtenkanalen en agents uitvoeren. Gebruik meerdere Gateways alleen wanneer je redundantie nodig hebt (bijv. rescue-bot) of harde isolatie.

Ja, maar je moet isoleren:

• OPENCLAW_CONFIG_PATH (configuratie per instantie)
• OPENCLAW_STATE_DIR (state per instantie)
• agents.defaults.workspace (workspace-isolatie)
• gateway.port (unieke poorten)

Snelle setup (aanbevolen):

• Gebruik openclaw --profile <name> ... per instantie (maakt automatisch ~/.openclaw-<name> aan).
• Stel een unieke gateway.port in elke profielconfiguratie in (of geef --port mee voor handmatige runs).
• Installeer een service per profiel: openclaw --profile <name> gateway install.

Profielen voegen ook suffixen toe aan servicenamen (ai.openclaw.<profile>; legacy com.openclaw.*, openclaw-gateway-<profile>.service, OpenClaw Gateway (<profile>)). Volledige gids: Meerdere gateways.

De Gateway is een WebSocket-server en verwacht dat het allereerste bericht een connect-frame is. Als er iets anders binnenkomt, sluit hij de verbinding met code 1008 (beleidsschending).

Veelvoorkomende oorzaken:

• Je hebt de HTTP-URL in een browser geopend (http://...) in plaats van een WS-client te gebruiken.
• Je hebt de verkeerde poort of het verkeerde pad gebruikt.
• Een proxy of tunnel heeft auth-headers verwijderd of een niet-Gateway-verzoek verzonden.

Snelle oplossingen:

1. Gebruik de WS-URL: ws://<host>:18789 (of wss://... bij HTTPS).
2. Open de WS-poort niet in een normaal browsertabblad.
3. Als auth is ingeschakeld, neem dan de token/het wachtwoord op in het connect-frame.

Als je de CLI of TUI gebruikt, moet de URL er zo uitzien:

openclaw tui --url ws://<host>:18789 --token <token>

Protocoldetails: Gateway-protocol.

Bestandslogs (gestructureerd):

/tmp/openclaw/openclaw-YYYY-MM-DD.log

Je kunt een stabiel pad instellen via logging.file. Het logniveau voor bestanden wordt beheerd door logging.level. Console-uitgebreidheid wordt beheerd door --verbose en logging.consoleLevel.

Snelste log-tail:

openclaw logs --follow

Service-/supervisorlogs (wanneer de gateway via launchd/systemd draait):

• macOS: $OPENCLAW_STATE_DIR/logs/gateway.log en gateway.err.log (standaard: ~/.openclaw/logs/...; profielen gebruiken ~/.openclaw-<profile>/logs/...)
• Linux: journalctl --user -u openclaw-gateway[-<profile>].service -n 200 --no-pager
• Windows: schtasks /Query /TN "OpenClaw Gateway (<profile>)" /V /FO LIST

Zie Probleemoplossing voor meer.

Gebruik de gateway-helpers:

openclaw gateway status
openclaw gateway restart

Als je de gateway handmatig uitvoert, kan openclaw gateway --force de poort terugnemen. Zie Gateway.

Er zijn twee Windows-installatiemodi:

1) WSL2 (aanbevolen): de Gateway draait binnen Linux.

Open PowerShell, ga naar WSL en herstart daarna:

wsl
openclaw gateway status
openclaw gateway restart

Als je de service nooit hebt geïnstalleerd, start deze dan op de voorgrond:

openclaw gateway run

2) Native Windows (niet aanbevolen): de Gateway draait rechtstreeks in Windows.

Open PowerShell en voer uit:

openclaw gateway status
openclaw gateway restart

Als je hem handmatig uitvoert (geen service), gebruik dan:

openclaw gateway run

Docs: Windows (WSL2), Gateway-service-runbook.

Begin met een snelle health-sweep:

openclaw status
openclaw models status
openclaw channels status
openclaw logs --follow

Veelvoorkomende oorzaken:

• Model-authenticatie niet geladen op de Gateway-host (controleer models status).
• Kanaalkoppeling/allowlist blokkeert antwoorden (controleer kanaalconfiguratie + logs).
• WebChat/Dashboard is geopend zonder het juiste token.

Als je extern bent, bevestig dan dat de tunnel-/Tailscale-verbinding actief is en dat de Gateway-WebSocket bereikbaar is.

Docs: Kanalen, Probleemoplossing, Externe toegang.

Dit betekent meestal dat de UI de WebSocket-verbinding is kwijtgeraakt. Controleer:

1. Draait de Gateway? openclaw gateway status
2. Is de Gateway gezond? openclaw status
3. Heeft de UI het juiste token? openclaw dashboard
4. Als je extern bent, is de tunnel-/Tailscale-link actief?

Bekijk daarna de logs live:

openclaw logs --follow

Docs: Dashboard, Externe toegang, Probleemoplossing.

Begin met logs en kanaalstatus:

openclaw channels status
openclaw channels logs --channel telegram

Koppel daarna de fout:

• BOT_COMMANDS_TOO_MUCH: het Telegram-menu heeft te veel items. OpenClaw kort al in tot de Telegram-limiet en probeert opnieuw met minder opdrachten, maar sommige menu-items moeten nog steeds worden verwijderd. Verminder plugin-/skill-/aangepaste opdrachten, of schakel channels.telegram.commands.native uit als je het menu niet nodig hebt.
• TypeError: fetch failed, Network request for 'setMyCommands' failed!, of vergelijkbare netwerkfouten: als je op een VPS zit of achter een proxy, bevestig dan dat uitgaande HTTPS is toegestaan en DNS werkt voor api.telegram.org.

Als de Gateway extern is, zorg er dan voor dat je naar logs op de Gateway-host kijkt.

Docs: Telegram, Kanaalprobleemoplossing.

Bevestig eerst dat de Gateway bereikbaar is en de agent kan draaien:

openclaw status
openclaw models status
openclaw logs --follow

Gebruik in de TUI /status om de huidige status te zien. Als je antwoorden in een chatkanaal verwacht, zorg er dan voor dat aflevering is ingeschakeld (/deliver on).

Docs: TUI, Slash-opdrachten.

Als je de service hebt geïnstalleerd:

openclaw gateway stop
openclaw gateway start

Dit stopt/start de beheerde service (launchd op macOS, systemd op Linux). Gebruik dit wanneer de Gateway op de achtergrond als daemon draait.

Als je op de voorgrond draait, stop dan met Ctrl-C en daarna:

openclaw gateway run

Docs: Gateway-service-runbook.

• openclaw gateway restart: herstart de achtergrondservice (launchd/systemd).
• openclaw gateway: draait de Gateway op de voorgrond voor deze terminalsessie.

Als je de service hebt geïnstalleerd, gebruik dan de Gateway-opdrachten. Gebruik openclaw gateway wanneer je een eenmalige run op de voorgrond wilt.

Start de Gateway met --verbose om meer consoledetails te krijgen. Inspecteer daarna het logbestand op kanaalauthenticatie, modelroutering en RPC-fouten.

Uitgaande bijlagen van de agent moeten een MEDIA:<path-or-url>-regel bevatten (op een eigen regel). Zie OpenClaw-assistent instellen en Agent verzenden.

Verzenden via CLI:

openclaw message send --target +15555550123 --message "Here you go" --media /path/to/file.png

Controleer ook:

• Het doelkanaal ondersteunt uitgaande media en wordt niet geblokkeerd door allowlists.
• Het bestand valt binnen de groottelimieten van de provider (afbeeldingen worden verkleind tot maximaal 2048px).
• tools.fs.workspaceOnly=true beperkt verzenden vanaf lokale paden tot workspace, temp/media-store en door de sandbox gevalideerde bestanden.
• tools.fs.workspaceOnly=false laat MEDIA: host-lokale bestanden verzenden die de agent al kan lezen, maar alleen voor media plus veilige documenttypen (afbeeldingen, audio, video, PDF en Office-documenten). Platte tekst en bestanden die op geheimen lijken, worden nog steeds geblokkeerd.

Zie Afbeeldingen.

Behandel inkomende DM's als niet-vertrouwde invoer. De standaardinstellingen zijn ontworpen om risico te verminderen:

• Standaardgedrag op kanalen die DM's ondersteunen is koppeling:
  • Onbekende afzenders ontvangen een koppelingscode; de bot verwerkt hun bericht niet.
  • Keur goed met: openclaw pairing approve --channel <channel> [--account <id>] <code>
  • Openstaande aanvragen zijn beperkt tot 3 per kanaal; controleer openclaw pairing list --channel <channel> [--account <id>] als er geen code is aangekomen.
• DM's openbaar openen vereist expliciete opt-in (dmPolicy: "open" en allowlist "*").

Voer openclaw doctor uit om riskant DM-beleid zichtbaar te maken.

Nee. Promptinjectie gaat over niet-vertrouwde inhoud, niet alleen over wie de bot kan DM'en. Als je assistent externe inhoud leest (web zoeken/ophalen, browserpagina's, e-mails, docs, bijlagen, geplakte logs), kan die inhoud instructies bevatten die proberen het model over te nemen. Dit kan zelfs gebeuren als jij de enige afzender bent.

Het grootste risico ontstaat wanneer tools zijn ingeschakeld: het model kan worden misleid om context te exfiltreren of namens jou tools aan te roepen. Beperk de impact door:

• een alleen-lezen of tool-uitgeschakelde "reader"-agent te gebruiken om niet-vertrouwde inhoud samen te vatten
• web_search / web_fetch / browser uit te houden voor agents met tools ingeschakeld
• gedecodeerde bestands-/documenttekst ook als niet-vertrouwd te behandelen: OpenResponses input_file en extractie van mediabijlagen verpakken geëxtraheerde tekst beide in expliciete grensmarkeringen voor externe inhoud in plaats van ruwe bestandstekst door te geven
• sandboxing en strikte tool-allowlists

Details: Beveiliging.

Ja, voor de meeste setups. De bot isoleren met aparte accounts en telefoonnummers verkleint de impact als er iets misgaat. Dit maakt het ook eenvoudiger om referenties te roteren of toegang in te trekken zonder je persoonlijke accounts te beïnvloeden.

Begin klein. Geef alleen toegang tot de tools en accounts die je echt nodig hebt, en breid later uit indien nodig.

Docs: Beveiliging, Koppeling.

We raden volledige autonomie over je persoonlijke berichten niet aan. Het veiligste patroon is:

• Houd DM's in koppelingsmodus of met een strakke allowlist.
• Gebruik een apart nummer of account als je wilt dat het namens jou berichten verstuurt.
• Laat het een concept maken en keur goed vóór verzending.

Als je wilt experimenteren, doe dat dan op een speciaal account en houd het geïsoleerd. Zie Beveiliging.

Ja, als de agent alleen chat gebruikt en de invoer vertrouwd is. Kleinere tiers zijn gevoeliger voor instructie-overname, dus vermijd ze voor agents met tools ingeschakeld of bij het lezen van niet-vertrouwde inhoud. Als je een kleiner model moet gebruiken, sluit tools dan af en draai binnen een sandbox. Zie Beveiliging.

Koppelingscodes worden alleen verzonden wanneer een onbekende afzender de bot een bericht stuurt en dmPolicy: "pairing" is ingeschakeld. /start genereert op zichzelf geen code.

Controleer openstaande aanvragen:

openclaw pairing list telegram

Als je directe toegang wilt, zet dan je afzender-id op de allowlist of stel dmPolicy: "open" in voor dat account.

Nee. Het standaard-DM-beleid van WhatsApp is koppeling. Onbekende afzenders krijgen alleen een koppelingscode en hun bericht wordt niet verwerkt. OpenClaw antwoordt alleen op chats die het ontvangt of op expliciete verzendingen die jij activeert.

Keur koppeling goed met:

openclaw pairing approve whatsapp <code>

Toon openstaande aanvragen:

openclaw pairing list whatsapp

Prompt voor telefoonnummer in de wizard: dit wordt gebruikt om je allowlist/eigenaar in te stellen zodat je eigen DM's zijn toegestaan. Het wordt niet gebruikt voor automatisch verzenden. Als je op je persoonlijke WhatsApp-nummer draait, gebruik dan dat nummer en schakel channels.whatsapp.selfChatMode in.

De meeste interne of toolberichten verschijnen alleen wanneer verbose, trace of reasoning is ingeschakeld voor die sessie.

Los dit op in de chat waar je het ziet:

/verbose off
/trace off
/reasoning off

Als het nog steeds lawaaiig is, controleer dan de sessie-instellingen in de Control UI en zet verbose op overnemen. Bevestig ook dat je geen botprofiel gebruikt met verboseDefault ingesteld op on in config.

Docs: Denken en verbose, Beveiliging.

Stuur een van deze als zelfstandig bericht (geen slash):

stop
stop action
stop current action
stop run
stop current run
stop agent
stop the agent
stop openclaw
openclaw stop
stop don't do anything
stop do not do anything
stop doing anything
please stop
stop please
abort
esc
wait
exit
interrupt

Dit zijn afbreektriggers (geen slash-opdrachten).

Voor achtergrondprocessen (vanuit de exec-tool) kun je de agent vragen om uit te voeren:

process action:kill sessionId:XXX

Overzicht van slash-opdrachten: zie Slash-opdrachten.

De meeste opdrachten moeten worden verzonden als een zelfstandig bericht dat begint met /, maar enkele snelkoppelingen (zoals /status) werken ook inline voor afzenders op de allowlist.

OpenClaw blokkeert standaard cross-provider-berichten. Als een toolaanroep is gebonden aan Telegram, verstuurt die niet naar Discord tenzij je dit expliciet toestaat.

Schakel cross-provider-berichten in voor de agent:

{
  tools: {
    message: {
      crossContext: {
        allowAcrossProviders: true,
        marker: { enabled: true, prefix: "[from {channel}] " },
      },
    },
  },
}

Herstart de Gateway na het bewerken van config.

De wachtrijmodus bepaalt hoe nieuwe berichten omgaan met een lopende run. Gebruik /queue om modi te wijzigen:

• steer - zet alle openstaande sturing in de wachtrij voor de volgende modelgrens in de huidige run
• queue - verouderde sturing één voor één
• followup - voer berichten één voor één uit
• collect - bundel berichten en antwoord één keer
• steer-backlog - stuur nu en verwerk daarna de achterstand
• interrupt - breek de huidige run af en start opnieuw

Standaardmodus is steer. Je kunt opties zoals debounce:0.5s cap:25 drop:summarize toevoegen voor opvolgmodi. Zie Opdrachtenwachtrij en Sturingswachtrij.

In OpenClaw zijn referenties en modelselectie gescheiden. Het instellen van ANTHROPIC_API_KEY (of het opslaan van een Anthropic API-sleutel in auth-profielen) schakelt authenticatie in, maar het daadwerkelijke standaardmodel is wat je configureert in agents.defaults.model.primary (bijvoorbeeld anthropic/claude-sonnet-4-6 of anthropic/claude-opus-4-6). Als je No credentials found for profile "anthropic:default" ziet, betekent dit dat de Gateway geen Anthropic-referenties kon vinden in het verwachte auth-profiles.json voor de agent die draait.