​

Configuratie 🔧

• te beperken wie de bot kan activeren (channels.whatsapp.allowFrom, channels.telegram.allowFrom, enz.)
• groeps-toegestane lijsten + mention-gedrag te beheren (channels.whatsapp.groups, channels.telegram.groups, channels.discord.guilds, agents.list[].groupChat)
• berichtprefixen aan te passen (messages)
• de werkruimte van de agent in te stellen (agents.defaults.workspace of agents.list[].workspace)
• de standaardinstellingen van de ingebedde agent (agents.defaults) en sessiegedrag (session) af te stemmen
• per-agent identiteit in te stellen (agents.list[].identity)

Nieuw met configuratie? Bekijk de gids Configuration Examples voor volledige voorbeelden met gedetailleerde uitleg!

​

Strikte configvalidatie

• De Gateway start niet.
• Alleen diagnostische opdrachten zijn toegestaan (bijvoorbeeld: openclaw doctor, openclaw logs, openclaw health, openclaw status, openclaw service, openclaw help).
• Voer openclaw doctor uit om de exacte problemen te zien.
• Voer openclaw doctor --fix (of --yes) uit om migraties/reparaties toe te passen.

​

Schema + UI-hints

​

Toepassen + herstarten (RPC)

• raw (string) — JSON5-payload voor de volledige config
• baseHash (optioneel) — confighash van config.get (vereist wanneer er al een config bestaat)
• sessionKey (optioneel) — sleutel van de laatst actieve sessie voor de wake-up ping
• note (optioneel) — notitie om op te nemen in de herstart-sentinel
• restartDelayMs (optioneel) — vertraging vóór herstart (standaard 2000)

openclaw gateway call config.get --params '{}' # capture payload.hash
openclaw gateway call config.apply --params '{
  "raw": "{\\n  agents: { defaults: { workspace: \\"~/.openclaw/workspace\\" } }\\n}\\n",
  "baseHash": "<hash-from-config.get>",
  "sessionKey": "agent:main:whatsapp:dm:+15555550123",
  "restartDelayMs": 1000
}'

​

Gedeeltelijke updates (RPC)

• objecten worden recursief samengevoegd
• null verwijdert een sleutel
• arrays worden vervangen Net als config.apply valideert het, schrijft de config weg, slaat een herstart-sentinel op en plant de Gateway-herstart (met een optionele wake wanneer sessionKey is opgegeven).

• raw (string) — JSON5-payload met alleen de te wijzigen sleutels
• baseHash (vereist) — confighash van config.get
• sessionKey (optioneel) — sleutel van de laatst actieve sessie voor de wake-up ping
• note (optioneel) — notitie om op te nemen in de herstart-sentinel
• restartDelayMs (optioneel) — vertraging vóór herstart (standaard 2000)

openclaw gateway call config.get --params '{}' # capture payload.hash
openclaw gateway call config.patch --params '{
  "raw": "{\\n  channels: { telegram: { groups: { \\"*\\": { requireMention: false } } } }\\n}\\n",
  "baseHash": "<hash-from-config.get>",
  "sessionKey": "agent:main:whatsapp:dm:+15555550123",
  "restartDelayMs": 1000
}'

​

Minimale config (aanbevolen startpunt)

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

scripts/sandbox-setup.sh

​

Zelf-chatmodus (aanbevolen voor groepscontrole)

{
  agents: {
    defaults: { workspace: "~/.openclaw/workspace" },
    list: [
      {
        id: "main",
        groupChat: { mentionPatterns: ["@openclaw", "reisponde"] },
      },
    ],
  },
  channels: {
    whatsapp: {
      // Allowlist is DMs only; including your own number enables self-chat mode.
      allowFrom: ["+15555550123"],
      groups: { "*": { requireMention: true } },
    },
  },
}

​

Config-includes ($include)

• Het organiseren van grote configs (bijv. per-client agentdefinities)
• Het delen van gemeenschappelijke instellingen tussen omgevingen
• Het gescheiden houden van gevoelige configs

​

Basisgebruik

// ~/.openclaw/openclaw.json
{
  gateway: { port: 18789 },

  // Include a single file (replaces the key's value)
  agents: { $include: "./agents.json5" },

  // Include multiple files (deep-merged in order)
  broadcast: {
    $include: ["./clients/mueller.json5", "./clients/schmidt.json5"],
  },
}

// ~/.openclaw/agents.json5
{
  defaults: { sandbox: { mode: "all", scope: "session" } },
  list: [{ id: "main", workspace: "~/.openclaw/workspace" }],
}

​

Samenvoeggedrag

• Enkel bestand: Vervangt het object dat $include bevat
• Array van bestanden: Diep samenvoegen in volgorde (latere bestanden overschrijven eerdere)
• Met sibling-sleutels: Sibling-sleutels worden na includes samengevoegd (overschrijven inbegrepen waarden)
• Sibling-sleutels + arrays/primitieven: Niet ondersteund (ingesloten inhoud moet een object zijn)

// Sibling keys override included values
{
  $include: "./base.json5", // { a: 1, b: 2 }
  b: 99, // Result: { a: 1, b: 99 }
}

​

Geneste includes

// clients/mueller.json5
{
  agents: { $include: "./mueller/agents.json5" },
  broadcast: { $include: "./mueller/broadcast.json5" },
}

​

Pad resolutie

• Relatieve paden: Opgelost relatief aan het insluitende bestand
• Absolute paden: Ongewijzigd gebruikt
• Bovenliggende mappen: ../-referenties werken zoals verwacht

{ "$include": "./sub/config.json5" }      // relative
{ "$include": "/etc/openclaw/base.json5" } // absolute
{ "$include": "../shared/common.json5" }   // parent dir

​

Fout bij behandeling

• Ontbrekend bestand: Duidelijke fout met opgelost pad
• Parsefout: Toont welk ingesloten bestand faalde
• Circulaire includes: Gedetecteerd en gerapporteerd met include-keten

​

Voorbeeld: Multi-client juridische setup

// ~/.openclaw/openclaw.json
{
  gateway: { port: 18789, auth: { token: "secret" } },

  // Common agent defaults
  agents: {
    defaults: {
      sandbox: { mode: "all", scope: "session" },
    },
    // Merge agent lists from all clients
    list: { $include: ["./clients/mueller/agents.json5", "./clients/schmidt/agents.json5"] },
  },

  // Merge broadcast configs
  broadcast: {
    $include: ["./clients/mueller/broadcast.json5", "./clients/schmidt/broadcast.json5"],
  },

  channels: { whatsapp: { groupPolicy: "allowlist" } },
}

// ~/.openclaw/clients/mueller/agents.json5
[
  { id: "mueller-transcribe", workspace: "~/clients/mueller/transcribe" },
  { id: "mueller-docs", workspace: "~/clients/mueller/docs" },
]

// ~/.openclaw/clients/mueller/broadcast.json5
{
  "[email protected]": ["mueller-transcribe", "mueller-docs"],
}

​

Veelvoorkomende opties

​

Env vars + .env

• .env uit de huidige werkdirectory (indien aanwezig)
• een globale fallback .env uit ~/.openclaw/.env (oftewel $OPENCLAW_STATE_DIR/.env)

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

​

env.shellEnv (optioneel)

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

• OPENCLAW_LOAD_SHELL_ENV=1
• OPENCLAW_SHELL_ENV_TIMEOUT_MS=15000

​

Env-var substitutie in config

{
  models: {
    providers: {
      "vercel-gateway": {
        apiKey: "${VERCEL_GATEWAY_API_KEY}",
      },
    },
  },
  gateway: {
    auth: {
      token: "${OPENCLAW_GATEWAY_TOKEN}",
    },
  },
}

• Alleen hoofdletter-env-varnamen worden gematcht: [A-Z_][A-Z0-9_]*
• Ontbrekende of lege env vars veroorzaken een fout bij het laden van de config
• Escapen met $${VAR} om een letterlijke ${VAR} uit te voeren
• Werkt met $include (ingesloten bestanden krijgen ook substitutie)

{
  models: {
    providers: {
      custom: {
        baseUrl: "${CUSTOM_API_BASE}/v1", // → "https://api.example.com/v1"
      },
    },
  },
}

​

Auth opslag (OAuth + API keys)

• <agentDir>/auth-profiles.json (standaard: ~/.openclaw/agents/<agentId>/agent/auth-profiles.json)

• ~/.openclaw/credentials/oauth.json (of $OPENCLAW_STATE_DIR/credentials/oauth.json)

• <agentDir>/auth.json (automatisch beheerd; niet handmatig bewerken)

• ~/.openclaw/agent/* (gemigreerd door openclaw doctor naar ~/.openclaw/agents/<defaultAgentId>/agent/*)

• OAuth dir (legacy import alleen): OPENCLAW_OAUTH_DIR
• Agent dir (standaard agent root overschrijven): OPENCLAW_AGENT_DIR (geprefereerd), PI_CODING_AGENT_DIR (legacy)

​

authenticatie

{
  auth: {
    profiles: {
      "anthropic:me@examplee. { provider: "anthropic", mode: "oauth", email: "me@example. },
      "antthropic:werk": { provider: "anthropic", modus: "api_key" },
    },
    order: {
      antthropice: ["anthropic:me@example. ", "antthropic:work"],
    },
  },
}

​

agents.list[].identity

• messages.ackReaction van de actieve agent’s identity.emoji (terugvalt naar 👀)
• agents.list[].groupChat.mentionPatterns van de agent identity.name/identity.emoji (dus “@Samantha” werkt in groepen over de verschillende Telegram/Slack/Discord/Google Chat/iMessage/WhatsApp)
• identity.avatar accepteert een workspace-relative image pad of een externe URL/data URL. Lokale bestanden moeten in de medewerker werkruimte wonen.

• Workspace-relatief pad (moet binnen de medewerkerwerkruimte blijven)
• http(s) URL
• data: URI

{
  agents: {
    lijst: [
      {
        id: "main",
        identiteit: {
          naam: "Samantha",
          thema: "nuttige sloth",
          emoji: "🦥",
          avatar: "avatars/samantha. ng",
        },
      },
    ],
  },
}

​

wizard

{
  wizard: {
    lastRunAt: "2026-01-01T00:00:00.000Z",
    lastRunVersion: "2026.1.4",
    lastRunCommit: "abc1234",
    lastRunCommand: "configure",
    lastRunMode: "local",
  },
}

​

logging

• Standaard logboekbestand: /tmp/openclaw/openclaw-YYYY-MM-DD.log
• Als je een stabiele route wilt, zet logging.file naar /tmp/openclaw/openclaw.log.
• Console uitvoer kan apart worden afgestemd:
  • logging.consoleLevel (standaard info, bumps to debug when --verbose)
  • logging.consoleStyle (pretty | compact | json)
• Gereedschap samenvattingen kunnen worden gewijzigd om lekken te voorkomen:
  • logging.redactSensitive (offtools, standaard: tools`)
  • logging.redactPatterns (array van regex strings; Overschrijft standaarden)

{
  logging: {
    level: "info",
    file: "/tmp/openclaw/openclaw og",
    consoleLevel: "info",
    consoleStijl: "pretty",
    redactSensitive: "tools",
    redactPatterns: [
      // Voorbeeld: override defaults met uw eigen regels.
      "\\bTOKEN\\b\\s*[=:]\\s*([\"']? ([^\\s\"']+)\\1",
      "/\\bsk-[A-Za-z0-9_-]{8,}\\b/gi",
    ],
  },
}

​

channels.whatsapp.dmPolicy

• "pairing" (standaard): onbekende afzenders krijgen een koppelingscode; eigenaar moet goedkeuren
• "allowlist": alleen afzenders toestaan in channels.whatsapp.allowFrom (of gekoppelde toestemming winkel)
• "open": sta alle inkomende DMs (requires channels.whatsapp.allowFrom toe om "*") toe te voegen
• "uitgeschakeld": negeer alle inkomende DMs

• openclaw pairing list whatsapp
• openclaw pairing keurt whatsapp <code>

​

channels.whatsapp.allowFrom

{
  channels: {
    whatsapp: {
      dmPolicy: "koppelen", // koppelen &gling-allowlist open open
      allowFrom: ["+155550123", "+447700900123"],
      textChunkLimit: 4000, // optionele uitgaande chunk grootte (tekens)
      chunkMode: "length", // optionele chunking modus (lengte ~newline)
      mediaMaxMb: 50, // optionele inkomende mediakap (MB)
    },
  },
}

​

channels.whatsapp.sendReadReceipts

{
  channels: {
    whatsapp: { sendReadReceipts: false },
  },
}

​

channels.whatsapp.accounts (multi-account)

{
  channels: {
    whatsapp: {
      accounts: {
        default: {}, // optioneel; houdt de standaard id stabiel
        persoonlijk: {},
        biz: {
          // Optionele overschrijving. Standaard: ~/.openclaw/credentials/whatsapp/biz
          // authDir: "~/. penclaw/inloggegevens/whatsapp/biz",
        },
      },
    },
  },
}

• Uitgaande commando’s standaard naar account default als aanwezig; anders het eerste geconfigureerde account id (gesorteerd).
• De legacy enkele account Baileys auth dir is gemigreerd door openclaw doctor naar whatsapp/default.

​

channels.telegram.accounts / channels.discord.accounts / channels.googlechat.accounts / channels.slack.accounts / channels.mattermost.accounts / channels.signa.accounts / channels.imessage.accounts

{
  channels: {
    telegram: {
      accounts: {
        default: {
          name: "Primary bot",
          botToken: "123456:ABC... ,
        },
        waarschuwingen: {
          naam: "Alerts bot",
          botToken: "987654:XYZ. .",
        },
      },
    },
  },
}

• default wordt gebruikt wanneer accountId is weggelaten (CLI + routing).
• Env tokens zijn alleen van toepassing op het standaard account.
• Basiskanaal instellingen (groepsbeleid, vermelding gating, etc.) Van toepassing op alle accounts tenzij deze per account overschreven worden.
• Gebruik bindings[].match.accountId om elk account naar een andere agents.standaard te verplaatsen.

​

Groepschat vermelden gating (agents.list[].groupChat + messages.groupChat)

• Metadata vermeldingen: Native platform @-vermeldt (bijv. WhatsApp tap-to-mention). Genegeerd in WhatsApp self-chat modus (zie channels.whatsapp.allowFrom).
• Tekstpatronen: Regex patronen gedefinieerd in agents.list[].groupChat.mentionPatterns. Altijd gecontroleerd, ongeacht de zelf-chatmodus.
• Het vermelden van gating is alleen afgedwongen wanneer vermelding detectie mogelijk is (native vermeldt of ten minste één mentionPattern).

{
  berichten: {
    groupChat: { historyLimit: 50 },
  },
  agents: {
    lijst: [{ id: "main", groepChat: { mentionPatterns: ["@openclaw", "openclaw"] } }],
  },
}

​

DM geschiedenis limieten

{
  channels: {
    telegram: {
      dmHistoryLimit: 30, // beperken van DM sessies tot 30 gebruikers draait
      dms: {
        "123456789": { historyLimit: 50 }, // Gebruikersoverschrijving (gebruiker ID)
      },
    },
  },
}

1. Per-DM overschrijven: kanalen.<provider>.dms[userId].historyLimit
2. Provider standaard: kanalen.<provider>.dmHistoryLimit
3. Geen limiet (alle geschiedenis behouden)

{
  agents: {
    lijst: [
      { id: "werk", groupChat: { mentionPatterns: ["@workbot", "\\+15555550123"] } },
      { id: "persoonlijk", groupChat: { mentionPatterns: ["@homebot", "\\+155550999"] } },
    ],
  },
}

{
  channels: {
    whatsapp: {
      // Bevat je eigen nummer om self-chat mode in te schakelen (negeer native @-mentions).
      allowVan: ["+155550123"],
      groepen: { "*": { requireMention: true } },
    },
  },
  agents: {
    lijst: [
      {
        id: "main",
        groepChat: {
          // Alleen deze tekst patronen zullen reacties veroorzaken
          mention Patterns: ["reisponde", "@openclaw"],
        },
      },
    ],
  },
}

​

Groepsbeleid (per kanaal)

{
  channels: {
    whatsapp: {
      groepbeleid: "allowlist",
      groupAllowFrom: ["+15551234567"],
    },
    telegram: {
      groepsbeleid: "allowlist",
      groupAllowFrom: ["tg:123456789", "@alice"],
    },
    signaal: {
      groupPolicy: "allowlist",
      groepstoelating van: ["+15551234567"],
    },
    imessage: {
      groupPolicy: "allowlist",
      groepAllowFrom: ["chat_id:123"],
    },
    msteams: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["user@org. om"],
    },
    discord: {
      groepbeleid: "allowlist",
      gilden: {
        GUILD_ID: {
          kanalen: { help: { allow: true } },
        },
      },
    },
    slack: {
      groepbeleid: "allowlist",
      kanalen: { "#general": { allow: true } },
    },
  },
}

• "open": groepen bypass allowlists; vermeldings-gating is nog steeds van toepassing.
• "Uitgeschakeld": blokkeer alle groep/room berichten.
• "allowlist": alleen groepsruimten toestaan die overeenkomen met de geconfigureerde allowlist.
• channels.defaults.groupPolicy stelt de standaard in wanneer een provider groupPolicy is vrijgegeven.
• WhatsApp/Telegram/Signal/iMessage/Microsoft Teams gebruiken groupAllowFrom (fallback: explicit allowFrom).
• Discord/Slack gebruikt kanaal allowlists (channels.discord.guilds.*.channels, channels.slack.channels).
• Group DMs (Discord/Slack) worden nog steeds bestuurd door dm.groupEnabled + dm.groupChannels.
• Standaard is groupPolicy: "allowlist"(tenzij overschreven door channels.defaults.groupPolicy`); als er geen toegestane lijst is geconfigureerd, worden groepsberichten geblokkeerd.

​

Multi-agent routering (agents.list + bindings)

• agents.list[]: per-agent overrides.
  • id: stable agent id (verplicht).
  • default: optioneel; als er meerdere zijn ingesteld, wint de eerste en wordt een waarschuwing gelogd. Als er geen één is ingesteld, is de eerste invoer in de lijst de standaard agent.
  • naam: toon naam voor de agent.
  • workspace: standaard ~/.openclaw/workspace-<agentId> (voor main, daalt terug naar agents.defaults.workspace).
  • agentDir: standaard ~/.openclaw/agents/<agentId>/agent.
  • model: per agent standaard model, overschrijft agents.defaults.model voor die agent.
    • tekenreeksformulier: "provider/model", overschrijft alleen agents.defaults.model.primary
    • object formulier: { primary, fallbacks } (overschrijft agents.defaults.model.fallbacks; [] schakelt globale fallbacks voor die agent)
  • identity: per-agent name/theme/emoji (gebruikt voor vermelding patronen + ack reactions).
  • groupChat: per-agent vermeld-gating (mentionPatterns).
  • sandbox: per-agent sandbox config (overschrijft agents.defaults.sandbox).
    • mode: "off" /h "niet-main" (Engels)
    • workspaceAccess: "none" Ο"ro" ~"rw"
    • scope: "session" credentials "agent" ”shared”`
    • workspaceRoot: aangepaste sandbox werkruimte root
    • docker: per-agent docker overrides (bijv. image, netwerk, env, setupCommand, limits; genegeerd wanneer scope: "shared")
    • browser: per-agent sandboxed browser overschrijvingen (genegeerd wanneer scope: "gedeeld")
    • prune: per-agent sandbox overschrijvingen verwijderen (genegeerd wanneer scope: "gedeeld")
  • subagents: per agent sub-agent standaard.
    • allowAgents: allowlist van agent ids voor sessions_spawn van deze agent (["*"] = sta iedereen toe; standaard: alleen dezelfde agent)
  • tools: per-agent tool restricties (toegepast voor het sandbox tool beleid).
    • profile: basis tool profiel (toegepast voor allow/deny)
    • allow: array van toegestane toolnamen
    • deny: array van ontkende tool namen (deny wins)
• agents.defaults: gedeelde agent standaard (model, werkruimte, sandbox, etc.).
• bindings[]: stuurt inkomende berichten door naar een agentId.
  • match.channel (verplicht)
  • match.accountId (optioneel; * = elk account; weggelaten = standaard account)
  • match.peer (optioneel; { kind: direct|group|channel, id })
  • match.guildId / match.teamId (optioneel; channel-specific)

1. match.peer
2. match.guildId
3. match.teamId
4. match.accountId (exact, geen peer/guild/team)
5. match.accountId: "*" (kanaalbreed, geen peer/guild/team)
6. standaard agent (agents.list[].default, anders eerste lijst invoer, anders `“main”)

​

Per‑agent toegangsprofielen (multi‑agent)

• Volledige toegang (persoonlijke agent)
• Alleen lezen tools + workspace
• Geen bestandssysteem toegang (alleen berichten/sessie-hulpmiddelen)

{
  agents: {
    list: [
      {
        id: "personal",
        workspace: "~/.openclaw/workspace-personal",
        sandbox: { mode: "off" },
      },
    ],
  },
}

{
  agents: {
    lijst: [
      {
        id: "familie",
        werkruimte: "~/. penclaw/workspace-family",
        sandbox: {
          modus: "alle",
          scope: "agent",
          Werkruimte: "ro",
        },
        hulpmiddelen: {
          toestaan: [
            "gelezen",
            "sessies_list",
            "sessions_historie",
            "sessions_send",
            "sessies_spawn",
            "session_status",
          ],
          weigering: ["write", "bewerk", "apply_patch", "exec", "process", "browser"],
        },
      },
    ],
  },
}

{
  agents: {
    lijst: [
      {
        id: "openbaar",
        werkruimte: "~/. penclaw/workspace-public",
        sandbox: {
          modus: "alle",
          scope: "agent",
          workspaceAccess: "geen",
        },
        hulpmiddelen: {
          toestaan: [
            "sessions_list",
            "sessies_historie",
            "sessions_send",
            "sessies_spawn",
            "session_status",
            "whatsapp",
            "telegram",
            "slack",
            "discord",
            "gateway",
          ],
          weigering: [
            "gelezen",
            "schrijven",
            "bewerken",
            "apply_patch",
            "exec",
            "proces",
            "browser",
            "canvas",
            "nodes",
            "kreet",
            "gateway",
            "afbeelding",
          ],
        },
      },
    ],
  },
}

{
  agents: {
    lijst: [
      { id: "home", standaard: waar, workspace: "~/. penclaw/workspace-home" },
      { id: "work", workspace: "~/. penclaw/workspace-work" },
    ],
  },
  bindings: [
    { agentId: "home", match: { channel: "whatsapp", accountId: "personal" } },
    { agentId: "work", match: { channel: "whatsapp", accountId: "biz" } },
  ],
  kanalen: {
    whatsapp: {
      accounts: {
        persoonlijk: {},
        biz: {},
      },
    },
  },
}

​

tools.agentToAgent (optioneel)

{
  tools: {
    agentToAgent: {
      ingeschakeld: false,
      allow: ["home", "work"],
    },
  },
}

​

berichten.wachtrij

{
  berichten: {
    wachtrij: {
      modus: "collect", // sturer ½ followup follow up waar je brug-backlog (steer+backlog ok) ½ interrupt (wachtrij=steer legacy)
      debounceMs: 1000,
      cap: 20,
      drop: "samenvatting", // oude, nieuw, samenvatting
      byChannel: {
        whatsapp: "collect",
        telegram: "verzamelen",
        discord: "verzamelen",
        impressie: "verzamelen",
        webchat: "verzamelen",
      },
    },
  },
}

​

messages.inbound

{
  berichten: {
    ingebonden: {
      debounceMs: 2000, // 0 schakelt
      byChannel: {
        whatsapp: 5000,
        slack: 1500,
        discord: 1500,
      },
    },
  },
}

• Debounce batches alleen tekst berichten; media en bijlagen onmiddellijk flush
• Bestuur commando’s (bijv. /queue, /new) bypass debouncing zodat ze zelfstandig blijven.

​

commands (chatopdracht afhandeling)

{
  commando's: {
    native: "auto", // native commando's registreren wanneer deze worden ondersteund (auto)
    tekst: waar, // parseer slash commando's in chatberichten
    bash: false, // sta toe! (alias: /bash) (alleen host-only; vereist hulpmiddelen. Verhoogd allowlists)
    bashForegroundMs: 2000, // bash vooreground window (0 achtergronden onmiddellijk)
    config: false, // sta /config (writes to disk)
    debug: false, // Sta /debug (runtime-only overrides)
    opnieuw start: false, // sta /herstart + gateway herstart tool
    useAccessGroups: true // afdwingen van toegang-groep toegestaan/beleid voor opdrachten
  },
}

• Tekst commando’s moeten worden verzonden als een standalone bericht en gebruik het toonaangevende / (geen platte-tekst alias).
• commands.text: valse schakelt het verwerken van chatberichten uit voor commando’s.
• commands.native: "auto" (standaard) schakelt oorspronkelijke commando’s in voor Discord/Telegram en laat Slack uit; niet-ondersteunde kanalen blijven text-only.
• Stel commands.native: true000000false in om alles te forceren, of overschrijf per kanaal met channels.discord.commands.native, channels.telegram.commands.native, channels.slack.commands.native (bool of "auto"). false` verwijdert eerder geregistreerde commando’s op Discord/Telegram bij het opstarten; Slack commando’s worden beheerd in de Slack app.
• channels.telegram.customCommands voegt extra Telegram bot menu-items toe. Namen worden genormaliseerd; conflicten met inheemse commando’s worden genegeerd.
• commands.bash: waar staat ! <cmd> om host commando’s uit te voeren (/bash <cmd> werkt ook als een alias). Vereist tools.elevated.enabled en sta het vermelden van de afzender toe in tools.elevated.allowFrom.<channel>.
• commands.bashForegroundMs bepaalt hoe lang bash wacht voor de achtergrond. Wanneer een bash job wordt uitgevoerd, nieuwe ! <cmd> verzoeken worden afgewezen (één tegelijk).
• commands.config: true stelt /config in (reads/writes openclaw.json).
• kanalen.<provider>.configWrites gates config mutaties geïnitieerd door dat kanaal (standaard: true). Dit geldt voor /config set+unnamed@@0 unset plus provider-specifieke auto-migraties (Telegram supergroup ID wijzigingen, Slack channel ID wijzigingen).
• commands.debug: true activeert /debug (runtime-only overrides).
• commands.restart: true stelt /restart in en de gateway tool start de actie opnieuw op.
• commands.useAccessGroups: false staat commando’s toe om toegang tot de lists/policy te omzeilen.
• Slash-opdrachten en directives worden alleen gehonoreerd voor geautoriseerde afzenders. Autorisatie is afgeleid van channel allowlists/pairing plus commands.useAccessGroups.

​

web (WhatsApp web channel runtime)

{
  web: {
    enabled: waar,
    heartbeatSeconden: 60,
    opnieuw verbinden: {
      initialMs: 2000,
      maxMs: 120000,
      factor: 1. ,
      jitter: 0. ,
      maxPotempts: 0,
    },
  },
}

​

channels.telegram (bot transport)

{
  channels: {
    telegram: {
      ingeschakeld: waar,
      botToken: "jouw-bot-token",
      dmPolicy: "koppelen", // Pauzeer Allowlist open open
      allowlist disabled 
 allowFrom: ["tg:123456789"], // optioneel; "open" vereist ["*"]
      groepen: {
        "*": { requireMention: true },
        "-10034567890": {
          allowFrom: ["@admin"],
          systeemsnel: "Houd antwoorden kort. ,
          onderwerpen: {
            "99": {
              requiretion: false,
              vaardigheden: ["zoeken"],
              systeemsnelheid: "Blijf op onderwerp. ,
            },
          },
        },
      },
      customCommandos: [
        { commando: "backup", beschrijving: "Git backup" },
        { commando: "genereren", beschrijving: "Maak een afbeelding" },
      ],
      historyLimiet: 50, // bevat laatste N groepsberichten als context (0 uitgeschakeld)
      replyToMode: "eerste", // korting op Ctrl+all
      linkPreview: true // schakel uitgaande link previews
      streamMode: "partial", // af van ×partiële partiële blok (draft streaming; scheiden van blok streaming)
      draftChunk: {
        // optioneel; alleen voor streamMode=block
        minuten: 200,
        maxChars: 800,
        breakPreference: "paragraph", // paragraaf duwt nieuwe-regel zin
      },
      acties: { reactions: true, sendMessage: true }, // tool actie poorten (false disables)
      reactionmeldingen: "own", // korting op Ctrl+own own all
      mediaMaxMb: 5,
      opnieuw: {
        // uitgaande herprobeer beleid
        pogingen: 3,
        minVertragingen: 400,
        maxDelayMs: 30000,
        jitter: 0. ,
      },
      netwerk: {
        // transport overschrijvingen
        autoSelectFamily: false,
      },
      proxy: "socks5://localhost:9050",
      webhookUrl: "https://voorbeeld. om/telegram-webhook", // vereist webhookSecret
      webhookSecret: "geheim",
      webhookPath: "/telegram-webhook",
    },
  },
}

• Gebruikt Telegram sendMessageDraft (conceptbubbel, geen echt bericht).
• Vereist privé chat onderwerpen (message_thread_id in DMs; bot heeft topics ingeschakeld).
• /reasoning stream streams redeneren in het ontwerp, stuurt dan het definitieve antwoord. Probeer de standaardinstellingen en het gedrag opnieuw in Probeer beleid.

​

kanalen.discord (bot transport)

{
  kanalen: {
    discord: {
      ingeschakeld: waar,
      token: "jouw-bot-token",
      mediaMaxMb: 8, // klem inkomende mediagrootte
      staat bots toe: false, // toestaan van door bot-authored berichten
      acties: {
        // tool actie poorten (false disables)
        reacties: true
        stickers: waar,
        polls: waar,
        rechten: waar,
        berichten: waar,
        threads: waar,
        pinnen: waar,
        zoeken: waar,
        lidInfo: waar,
        roleInfo: waar,
        rollen: false,
        kanaal: waar,
        voiceStatus: waar,
        gebeurtenissen: waar,
        moderatie: false,
      },
      replyToMode: "uit", // korting om eerst
      dm: {
        ingeschakeld: waar, // schakel alle DM's uit wanneer er vals
        -beleid is: "koppelen", // paireren ± allowlist open open uitgeschakeld
        allowFrom: ["1234567890", "steihuis"], // optionele DM allowlist ("open" vereist ["*"])
        groupEnabled: false, // activeer groep DMs
        groupChannels: ["openclaw-dm"], // optionele groep DM allowlist
      },
      guilds: {
        "123456789012345678": {
          // guild id (prefereerd) of slug
          slug: "friends-of-openclaw",
          benodigdheden: false, // per guild standaard
          reactiemeldingen: "eigen", // korting op Eigen eigen quad all allowlist
          gebruikers: ["987654321098765432"], // optioneel per gilde gebruiker toelaat lijst
          kanalen: {
            generaal: { allow: true },
            hulp: {
              toestaan: waar,
              vereisten: waar,
              gebruikers: ["987654321098765432"],
              vaardigheden: ["docs"],
              systeemsnelheid: "Korte antwoorden. ,
            },
          },
        },
      },
      historyLimiet: 20, // bevat laatste N gilde berichten als context
      textChunkLimit: 2000, // optionele uitgaande tekstchunk grootte (tekens)
      chunkMode: "length", // optionele chunking modus (lengte/nieuwregel)
      maxLinesPerMessage: 17, // zachte max regels per bericht (Discord UI clipping)
      opnieuw proberen: {
        // uitgaande opnieuw proberen beleid
        pogingen: 3,
        MinDelayMs: 500,
        maxDelayMs: 30000,
        jitter: 0. ,
      },
    },
  },
}

• off: geen reactiegebeurtenissen.
• own: reacties op de eigen berichten van de bot (standaard).
• all: alle reacties op alle berichten.
• allowlist: reacties van guilds.<id>.users op alle berichten (lege lijst schakelt uit). Uitgaande tekst is gechunked met channels.discord.textChunkLimit (standaard 2000). Stel channels.discord.chunkMode="newline" in om op lege regels (alinea-grenzen) te splitsen voor de lengte van het chunken. Discord clients kunnen zeer lange berichten clip maken, dus channels.discord.maxLinesPerMessage (standaard 17) splits veel reacties met meerdere regels, zelfs wanneer je minder dan 2000 tekens hebt. Probeer de standaardinstellingen en het gedrag opnieuw in Probeer beleid.

​

kanalen.googlechat (Chat API webhook)

{
  channels: {
    googlechat: {
      ingeschakeld: waar,
      serviceAccountFile: "/path/to/service-account. son",
      audienceType: "app-url", // app-url reached. project-number
      audience: "https://gateway.example. om/googlechat",
      webhookPath: "/googlechat",
      botUser: "users/1234567890", // optioneel; verbetert detectie
      dm: {
        ingeschakeld: waar,
        beleid: "koppelen", // Pauze allowlist paramopen open open
        allowFrom: ["users/1234567890"], // optioneel; "open" vereist ["*"]
      },
      groepbeleid: "allowlist",
      groepen: {
        "spaties/AAA": { allow: true, requireMention: true },
      },
      acties: { reactions: true },
      typingIndicator: "bericht",
      mediaMaxMb: 20,
    },
  },
}

• Service account JSON kan inline (serviceAccount) of bestand gebaseerd zijn (serviceAccountFile).
• Env fallbacks voor de standaard account: GOOGLE_CHAT_SERVICE_ACCOUNT of GOOGLE_CHAT_SERVICE_ACCOUNT_FILE.
• audienceType + audience moet overeenkomen met de webhook authenticatie configuratie van de Chat app.
• Gebruik spaties/<spaceId> of users/<userId|email> bij het instellen van leveringsdoelen.

​

kanalen.slack (socket modus)

{
  kanalen: {
    slack: {
      ingeschakeld: waar,
      botToken: "xoxb-. .",
      appToken: "xapp-... ,
      dm: {
        ingeschakeld: waar,
        beleid: "koppelen", // Koppelen ± allowlist open open
        allowFrom: ["U123", "U456", "*"], // optioneel; "open" vereist ["*"]
        groepIngeschakeld: false,
        groepkanalen: ["G123"],
      },
      kanalen: {
        C123: { allow: true, requireMention: true, allowBots: false },
        "#general": {
          toestaan: waar,
          vereisten: waar,
          staat boten toe: onwaar,
          gebruikers: ["U123"],
          vaardigheden: ["docs"],
          systeemPrompt: "Korte antwoorden. ,
        },
      },
      historyLimiet: 50, // voeg laatst N kanaal/groep berichten als context (0 is uitgeschakeld)
      staat toe: false,
      reactiemeldingen: "eigen", // Afwezigheid van signatures eigen kill is voor iedereen
      reactionAllowlist: ["U123"],
      replyToMode: "uit", // korting eerst
      thread: {
        historyScope: "thread", // thread ½ kanaal
        erfenis: false,
      },
      acties: {
        reacties: waar,
        berichten: waar,
        pinnen: waar,
        lidInfo: waar,
        emojiList: waar,
      },
      slashCommand: {
        ingeschakeld: waar,
        naam: "openclaw",
        sessionprefix: "slack:slash",
        ephemeral: true
      },
      textChunkLimit: 4000,
      chunkModus: "lengte",
      mediaMaxMb: 20,
    },
  },
}

• off: geen reactiegebeurtenissen.
• own: reacties op de eigen berichten van de bot (standaard).
• all: alle reacties op alle berichten.
• allowlist: reacties van channels.slack.reactionAllowlist op alle berichten (lege lijst uitgeschakeld).

• channels.slack.thread.historyScope bepaalt of de geschiedenis per thread is (thread, standaard) of gedeeld over het kanaal (kanaal).
• channels.slack.thread.inheritParent bepaalt of nieuwe thread sessies het bovenliggende kanaal transcript overnemen (standaard: false).

​

kanalen.matterste (bot token)

{
  kanalen: {
    matterste: {
      ingeschakeld: waar,
      botToken: "mm-token",
      baseUrl: "https://chat. xample.
      dmPolicy: "pairing",
      chatmode: "oncall", // onheus _PARAM0onchar
      oncharfixes: [">", "! ],
      textChunkLimit: 4000,
      chunkMode: "length",
    },
  },
}

• oncall (standaard): reageer alleen op kanaal berichten wanneer @mentioned.
• onmessage: reageer op elk kanaalbericht.
• onchar: reageer wanneer een bericht begint met een triggerprefix (channels.mattermost.oncharPrefixes, standaard [">", "!"]).

• Standaard DMs: channels.mattermost.dmPolicy="pairing" (onbekende afzenders krijgen een koppelcode).
• Openbare DM’s: channels.mattermost.dmPolicy="open" plus channels.mattermost.allowFrom=["*"].
• Groepen: channels.mattermost.groupPolicy="allowlist" standaard (vermelding-gated). Gebruik channels.mattermeestst.groupAllowFrom om afzenders te beperken.

​

kanalen.signal (signal-cli)

{
  channels: {
    signal: {
      reactionNotifications: "own", // off | own | all | allowlist
      reactionAllowlist: ["+15551234567", "uuid:123e4567-e89b-12d3-a456-426614174000"],
      historyLimit: 50, // include last N group messages as context (0 disables)
    },
  },
}

• off: geen reactiegebeurtenissen.
• own: reacties op de eigen berichten van de bot (standaard).
• all: alle reacties op alle berichten.
• allowlist: reacties van channels.signal.reactionAllowlist op alle berichten (lege lijst uitgeschakeld).

​

channels.imessage (imsg CLI)

{
  kanalen: {
    imessage: {
      ingeschakeld: waar,
      cliPath: "imsg",
      dbPath: "~/Library/Messages/chat. b",
      remoteHost: "user@gateway-host", // SCP voor externe bijlagen bij gebruik van SSH wrapper
      dmPolicy: "pairing", // paireren ½ allowlist open open
      allowFrom: ["+15555550123", "user@example". om", "chat_id:123"],
      historyLimiet: 50, // bevat laatste N groepsberichten als context (0 uitgeschakeld)
      inclusief: onwaar,
      mediaMaxMb: 16,
      service: "auto",
      regio: "VS",
    },
  },
}

• Volledige schijf toegang tot de Berichten DB vereist.
• De eerste verzending zal om berichten automatiseringstoestemming vragen.
• Voorkeur chat_id:<id> doelwitten. Gebruik imsg chats --limit 20 om chats weer te geven.
• channels.imessage.cliPath kan naar een wrapper script verwijzen (bijv. ssh naar een andere Mac die imsg rpc); gebruik SSH keys om wachtwoord aanwijzingen te vermijden.
• Voor externe SSH wrappers, stel channels.imessage.remoteHost in om bijlagen via SCP op te halen wanneer includeAttachments is ingeschakeld.

#!/usr/bin/env bash
exec ssh -T gateway-host imsg "$@"

​

agents.defaults.workspace

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

​

agents.defaults.repoRoot

{
  agents: { repoRoot: "~/Projects/openclaw" } },
 } }

​

agents.defaults.skipBootstrap

{
  agents: { defaults: { skipBootstrap: true } },
}

​

agents.defaults.bootstrapMaxChars

{
  agents: { defaults: { bootstrapMaxChars: 20000 } },
}

​

agents.defaults.userTimezone

{
  agents: { defaults: { userTimezone: "America/Chicago" } },
}

​

agents.defaults.timeFormat

{
  agents: { defaults: { timeFormat: "auto" } }, // auto γ12 ² 24
 } }

​

berichten

{
  berichten: {
    responsePrefix: "🦞", // of "auto"
    ackReaction: "👀",
    ackReactionScope: "group-mentions",
    removeAckAfterRepy: false,
  },
}

• channels.<channel>.responsePrefix
• channels.<channel>.accounts.<id>.responsePrefix

1. channels.<channel>.accounts.<id>.responsePrefix
2. channels.<channel>.responsePrefix
3. messages.responsePrefix

• undefined valt door naar het volgende level.
• "" schakelt expliciet de prefix uit en stopt de cascade.
• "auto" ontleent [{identity.name}] voor de routed agent.

​

Template variabelen

{
  berichten: {
    responsePrefix: "[{model} think:{thinkingLevel}]",
  },
}

• group-mentions (standaard): alleen wanneer een groep/kamer vereist en de bot is genoemd
• group-all: alle groeps/room berichten
• direct: verstuur alleen berichten
• alle: alle berichten

​

berichten.tts

{
  berichten: {
    tts: {
      auto: "altijd", // korting altijd ≤ inbound inbound
      mode: "final", // eindig elk (inclusief antwoorden op tool/blokkeringen)
      provider: "elevenlabs",
      samenvattyModel: "openai/gpt-4. -mini",
      modelOverrides: {
        enabled: true,
      },
      maxTextLengte: 4000,
      timeouts: 30000,
      prefsPath: "~/. penclaw/instellingen/tts. son",
      elevenlabs: {
        apiKey: "elevenlabs_api_key",
        baseUrl: "https://api. levenlabs. o",
        voiceId: "voice_id",
        modelId: "eleven_multilingual_v2",
        seed: 42,
        applyTextNormalisatie: "auto",
        languageCode: "en",
        voiceSettings: {
          stabiliteit: 0. ,
          vergelijkbare Boost: 0. 5,
          stijl: 0. ,
          useSpeakerBoost: waar,
          snelheid: 1. ,
        },
      },
      openai: {
        apiKey: "openai_api_key",
        model: "gpt-4o-mini-tts",
        stem: "alloy",
      },
    },
  },
}

• messages.tts.auto bestuurt autogithub.com/TTS (off, always, inbound, tagged).
• /tts off000000always+unnamed@@0 ongegrensd stelt de per/h sessie automatische instelling in (overrides config).
• messages.tts.enabled is legacy; doctor migreert het naar messages.tts.auto.
• prefsPath slaat lokale overrides op (provider/limit/summarize).
• maxTextLength is een harde bovengrens voor TTS input; samenvattingen zijn afgekapt om te passen.
• samenvatting Model overschrijft agents.defaults.model.primary voor auto-samenvatting.
  • Accepteert provider/model of een alias van agents.defaults.models.
• modelOverrides maakt model-gedreven overschrijvingen mogelijk, zoals [[tts:...]] tags (standaard aan).
• /tts limit and /tts summary control per-user summarization settings.
• apiKey waarden vallen terug naar ELEVENLABS_API_KEY/XI_API_KEY en OPENAI_API_KEY.
• elevenlabs.baseUrl overschrijft de ElevenLabs API basis URL.
• elevenlabs.voiceSettings ondersteunt stability/similarityBoost/style (0..1), useSpeakerBoost, en speed (0.5..2.0).

​

Spraak

{
  talk: {
    voiceId: "elevenlabs_voice_id",
    voiceAliases: {
      Klaar: "EXAVITQu4vr4xnSDxMaL",
      Roost: "CwhRBWXzGAHq8TQ4Fs17",
    },
    modelId: "eleven_v3",
    outputFormaat: "mp3_44100_128",
    apiKey: "elevenlabs_api_key",
    interruptOnSpeech: waar,
  },
}

​

agents.standaard

• alias (optioneel model snelkoppeling, bijv. /opus).
• params (optionele provider-specifieke API parameters doorgegeven aan het modelverzoek).

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-sonnet-4-20250929": {
          params: { temperature: 0.6 },
        },
        "openai/gpt-5. ": {
          params: { maxTokens: 8192 },
        },
      },
    },
  },
}

• zet --nadenken uit, of
• definieer agents.defaults.models["zai/<model>"].params.thinking zelf.

• opus -> anthropic/claude-opus-4-6
• sonnet -> anthropic/claude-sonnet-4-5
• gpt -> openai/gpt-5.2
• gpt-mini -> openai/gpt-5-mini
• gemini -> google/gemini-3-pro-preview
• gemini-flash -> google/gemini-3-flash-preview

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-opus-4-6": { alias: "opus" },
        "minimax/MiniMax-M2. ": { alias: "minimax" },
      },
      model: {
        primair: "anthropic/claude-opus-4-6",
        terugvalt: ["minimax/MiniMax-M2. "],
      },
    },
  },
}

​

agents.defaults.cliBackends (CLI terugval)

• CLI backends zijn text-first; hulpmiddelen zijn altijd uitgeschakeld.
• Sessies worden ondersteund wanneer sessionArg is ingesteld; sessie id’s worden per backend.
• Voor claude-cli, worden standaard bedraden. Overschrijf het opdrachtpad als de PATH minimaal is (launchd/system).

{
  agents: {
    defaults: {
      cliBackends: {
        "claude-cli": {
          command: "/opt/homebrew/bin/claude",
        },
        "my-cli": {
          commando: "my-cli",
          args: ["--json"],
          uitvoer: "json",
          modelArg: "--model",
          sessionArg: "--session",
          sessiemodus: "Bestaat",
          systemPromptArg: "--system",
          systemPromptWhen: "eerste",
          afbeelding: "--afbeelding",
          afbeeldingsmodus: "herhalen",
        },
      },
    },
  },
}

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-opus-4-6": { alias: "Opus" },
        "anthropic/claude-sonnet-4-1": { alias: "Sonnet" },
        "openrouter/deepseek/deepseek-r1:free": {},
        "zai/glm-4. ": {
          alias: "GLM",
          params: {
            dunking: {
              type: "enabled",
              clear_thinking: onwaar,
            },
          },
        },
      },
      model: {
        primair: "anthropic/claude-opus-4-6",
        terugvalt: [
          "openrouter/deepseek/deepseek-r1:free",
          "openrouter/meta-llama/llama-3. -70b-instruct:gratis",
        ],
      },
      imageModel: {
        primair: "openrouter/qwen/qwen-2. -vl-72b-instruct:free",
        gevallen terug: ["openrouter/google/gemini-2. -flash-vision:free"],
      },
      denkstandaard: "laag",
      verboseStandaard: "uit",
      standaardinstelling: "aan",
      time-outseconden: 600,
      mediaMaxMb: 5,
      hartjes: {
        elke: "30m",
        doel: "laat",
      },
      maxConcurrent: 3,
      subagents: {
        model: "minimax/MiniMax-M2. ",
        maxConcurrent: 1,
        archiveAfterMinuten: 60,
      },
      exec: {
        achtergronden: 10000,
        timeout: 1800,
        schoonmaakapparaten: 1800000,
      },
      contextTokens: 200000,
    },
  },
}

​

agents.defaults.contextPruning (tool-result pruning)

• Nooit gebruiker/assistent berichten aanraken.
• Beschermt de laatste keepLastAssistants assistenten berichten (geen tool resultaten na dat punt zijn verwijderd).
• Beschermt het bootstrap voorvoegsel (niets voordat het eerste gebruikersbericht is verwijderd).
• Modus:
  • adaptive: soft-trims overmaat aan gereedschap (houd hoofd/tail) wanneer de geschatte context ratio softTrimRatio kruist. Daarna moet je de oudste geschikte tool wissen wanneer de geschatte context ratio hardClearRatio en overschrijdt. Er is genoeg schattige tool-resultaat bulk (minPrunableToolChars).
  • agressieve: vervangt altijd geschikte gereedschap resultaten voor de cutoff door hardClear.placeholder (geen ratio controleerd).

• Soft-trim**: alleen voor overgrootte werkresultaten. Houdt het begin + einde en voegt ... in het midden.
  • Voor: toolResult("…zeer lange uitvoer…")
  • Na: toolResult("HEAD…\n...\n…TAIL\n\n[Resultaat Gereedschap: …]")
• Hard-clear: vervangt het volledige resultaat door de placeholder.
  • Voor: toolResult("…zeer lange uitvoer…")
  • Nade: toolResult("[Oude tool result content cleared]")

• Resultaten met afbeeldingsblokken worden overgeslagen (nooit ingekort) op dit moment.
• De geschatte “context ratio” is gebaseerd op karakters (bij benadering inbegrepen), niet op exacte tokens.
• Als de sessie ten minste keepLastAssistants assistenten nog niet bevat, wordt printen overgeslagen.
• In de agressive modus, wordt hardClear.enabled genegeerd (geschikte tool resultaten worden altijd vervangen door hardClear.placeholder).

{
  agents: { contextPruning: { mode: "adaptive" } },
 } } } } } } } } } } } } } }

{
  agents: { defaults: { contextPruning: { mode: "off" } },
 } } } } } } } } } } } } } }

• keepLastAssistants: 3
• softTrimRatio: 0.3 (alleen adaptief)
• hardClearRatio: 0.5 (alleen adaptief)
• minPrunableToolChars: 50000 (alleen adaptief)
• softTrim: { maxChars: 4000, headChars: 1500, tailChars: 1500 } (alleen adaptief)
• hardClear: { enabled: true, placeholder: "[Old tool result content cleared]" }

{
  agents: { defaults: { contextPruning: { mode: "aggressive" } },
 } } } } } } } } } }

{
  agents: {
    defaults: {
      contextPruning: {
        mode: "adaptive",
        keepLastLastAssistants: 3,
        softTrimRatio: 0. ,
        hardClearRatio: 0. ,
        minPrunableToolChars: 50000,
        softTrim: { maxChars: 4000, headChars: 1500, tailChars: 1500 },
        hardClear: { ingeschakeld: waar, placeholder: "[Oude tool result content cleared]" },
        // Optioneel: beperken tot specifieke tools (weiger wins; ondersteunt "*" jokertekens)
        hulpmiddelen: { deny: ["browser", "canvas"] },
      },
    },
  },
}

​

agents.defaults.compaction (reserveer hoofdkamer + geheugen flush)

• memoryFlush.enabled: true
• memoryFlush.softThresholdTokens: 4000
• memoryFlush.prompt / memoryFlush.systemPrompt: ingebouwde standaard met NO_REPLY
• Opmerking: de geheugenflush wordt overgeslagen wanneer de sessie-werkruimte alleen-lezen- (agents.defaults.sandbox.workspaceAccess: "ro" or "none").

{
  agents: {
    defaults: {
      komaction: {
        mode: "security d",
        reserveTokensFloor: 24000,
        geheugenFlush: {
          ingeschakeld: waar,
          softThresholdTokens: 6000,
          systemPrompt: "Sessie nadert compact. Sla duurzame herinneringen nu op.",
          prompt: "Schrijf blijvende notities naar geheugen/YYYY-MM-DD. ; antwoord met NO_REPLY als er niets op te slaan is. ,
        },
      },
    },
  },
}

• agents.defaults.blockStreamingDefault: "on"/"off" (standaard uit).
• Kanaal overschrijven: *.blockStreaming (en per-account varianten) om streaming gedwongen aan of uit te schakelen. Voor niet-Telegram-kanalen zijn expliciete *.blockStreaming: true nodig om antwoorden te blokkeren.
• agents.defaults.blockStreamingBreak: "text_end" or """message_end" (standaard: text_end).
• agents.defaults.blockStreamingChunk: soft chunking voor gestreamde blokken. Standaard 800–1200 tekens, geeft de voorkeur aan alinea-pauzes (\n\n), dan nieuwkomers, en vervolgens zinnen. Voorbeeld:
  {
    agents: { defaults: { blockStreamingChunk: { minChars: 800, maxChars: 1200 } } },
   } }
  
• agents.defaults.blockStreamingCoalesce: voeg gestreamde blokken samen voor het verzenden. Standaard ingesteld op { idleMs: 1000 } en erft minChars van blockStreamingChunk met maxChars gemaximaliseerd aan het kanaal tekstlimiet. Signal/Slack/Discord/Google Chat standaard naar minChars: 1500 tenzij dit wordt overschreven. Channel overrides: channels.whatsapp.blockStreamingCoalesce, channels.telegram.blockStreamingCoalesce, channels.discord.blockStreamingCoalesce, channels.slack.blockStreamingCoalesce, channels.mattermost.blockStreamingCoalesce, channels.signal.blockStreamingCoalesce, channels.imessage.blockStreamingCoalesce, channels.msteams.blockStreamingCoalesce, channels.googlechat.blockStreamingCoalesce (and per-account variants).
• agents.defaults.humanDelay: willekeurige pauze tussen blok antwoorden na de eerste. Modes: off (standaard), natuurlijk (800–2500ms), custom (gebruik minMs/maxMs). Overschrijven Per-agent: agents.list[].humanDelay. Voorbeeld:
  {
    agents: { humanDelay: { mode: "natural" } },
   } } } } } } } } } } } } }
  
  Zie /concepts/streaming voor gedrag + details in stukken snijden.

• agents.defaults.typingMode: "nooit" Onmiddellijk "instant" (INT "bezinnen"! bericht". Standaard instant voor directe chats / vermeldingen en message voor ongenoemde groeps-chats.
• session.typingMode: per-session override voor de modus.
• agents.defaults.typingIntervalSeconds: hoe vaak het typingssignaal wordt vernieuwd (standaard: 6s).
• session.typingIntervalSeconds: per sessie overschrijving voor de refresh interval. Zie /concepts/typing-indicators voor gedragsdetails.

• every: duration string (ms, s, m, h); standaard unit minuten. Standaard: 30m. Zet 0m om uit te schakelen.
• model: optioneel override model voor heartbeat run (provider/model).
• includeReasoning: Wanneer true, zal heartbeats ook het aparte Reasoning: bericht leveren indien beschikbaar (dezelfde vorm als /reasoning on). Standaard: false.
• session: optionele sessie sleutel om te bepalen in welke sessie de heartbeat plaatsvindt. Standaard: main.
• to: optionele ontvanger override (kanaal-specifieke id, bijv. E.164 voor WhatsApp, chat id voor Telegram).
• target: optioneel uitleveringskanaal (last, whatsapp, telegram, discord, slack, msteams, signal, imessage, none). Standaard: laatste.
• prompt: optionele overschrijving voor het hart-lichaam (standaard: Lees HEARTBEAT.md als het bestaat (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.). Overrides worden verbatim verzonden; inclusief een Lees HEARTBEAT.md regel als je het bestand nog wilt lezen.
• ackMaxChars: max tekens toegestaan na HEARTBEAT_OK voor levering (standaard: 300).

• Stel agents.list[].heartbeat in of overschrijf hartebeat instellingen voor een specifieke agent.
• Als een agent item heartbeat definieert, alleen die agents draaien hartbekken; standaard wordt de gedeelde baseline voor die agents.

• backgroundMs: tijd voor auto-achtergrond (ms, standaard 10000)
• timeoutSec: auto-kill na deze runtime (seconden, standaard 1800)
• cleanupMs: hoe lang de beëindigde sessies in het geheugen te houden (ms, standaard 1800000)
• notifyOnExit: enque een systeem event + verzoek hartebeat wanneer de achtergrond exec exits (standaard waar)
• applyPatch.enabled: schakel experimentele apply_patch in (alleen OpenAI/OpenAI Codex; standaard false)
• applyPatch.allowModels: optionele allowlist van model id’s (bijv. gpt-5.2 of openai/gpt-5.2) Opmerking: applyPatch staat alleen onder tools.exec.

• tools.web.search.enabled (standaard: true wanneer de sleutel aanwezig is)
• tools.web.search.apiKey (aanbevolen: set via openclaw configureren --section web, of gebruik BRAVE_API_KEY env var)
• tools.web.search.maxResults (1-10, standaard 5)
• tools.web.search.timeoutSeconds (standaard 30)
• tools.web.search.cacheTtlMinutes (standaard 15)
• tools.web.fetch.enabled (standaard waar)
• tools.web.fetch.maxChars (standaard 50000)
• tools.web.fetch.maxCharsCap (standaard 50000; duwt maxChars in config/tool calls)
• tools.web.fetch.timeoutSeconds (standaard 30)
• tools.web.fetch.cacheTtlMinutes (standaard 15)
• tools.web.fetch.userAgent (optionele override)
• tools.web.fetch.readability (standaard waar; uitschakelen om alleen HTML opruimen te gebruiken)
• tools.web.fetch.firecrawl.enabled (standaard waar wanneer een API sleutel is ingesteld)
• tools.web.fetch.firecrawl.apiKey (optioneel; standaard FIRECRAWL_API_KEY)
• tools.web.fetch.firecrawl.baseUrl (standaard https://api.firecrawl.dev)
• tools.web.fetch.firecrawl.onlyMainContent (standaard waar)
• tools.web.fetch.firecrawl.maxAgeMs (optioneel)
• tools.web.fetch.firecrawl.timeoutSeconds (optioneel)

• tools.media.models: gedeelde modellijst (capability-tagged; gebruikt na per-cap lists).
• tools.media.concurrency: max gelijktijdige capaciteit draait (standaard 2).
• tools.media.image / tools.media.audio / tools.media.video:
  • enabled: opt-out schakelaar (standaard true wanneer modellen zijn geconfigureerd).
  • prompt: optioneel prompt override (afbeelding / video voeg automatisch een maxChars hint toe).
  • maxChars: max output karakters (standaard 500 voor image/video; unset voor audio).
  • maxBytes: max mediagrootte om te verzenden (standaard: afbeelding 10MB, audio 20MB, video 50MB).
  • timeoutSeconds: verzoektime-out (standaard: afbeelding 60s, audio 60s, video 120s).
  • language: optionele audio hint.
  • attachments: attachment policy (mode, maxAttachments, prefer).
  • scope: optionele gating (eerste match wint) met match.channel, match.chatType, of match.keyPrefix.
  • models: geordende lijst van model items; mislukte of te grote media vallen terug naar de volgende invoer.
• Elke models[] invoer:
  • Zoekmachine item (type: "provider" of weggelaten):
    • provider: API providerid (openai, anthropic, google/gemini, groq, etc).
    • model: model id override (vereist voor afbeelding; standaard gpt-4o-mini-transcribe/whisper-large-v3-turbo voor audio providers, en gemini-3-flash-preview voor video).
    • profile / preferredProfile: authprofiel selectie.
  • CLI item (`type: “cli”):
    • command: uitvoerbaar om te gebruiken.
    • args: getemplated args (ondersteund {{MediaPath}}, {{Prompt}}, {{MaxChars}}, etc).
  • capabilities: optionele lijst (image, audio, video) om een gedeelde invoer te gaten. Standaard wanneer weggewezen: openai/anthropic/minimax → afbeelding, google → image+audio+video, groq → audio.
  • prompt, maxChars, maxBytes, timeoutSeconds, language kan worden overschreven per invoer.

{
  tools: {
    media: {
      audio: {
        enabled: waar,
        maxBytes: 20971520,
        toepassingsgebied: {
          standaard: "weigeren",
          regels: [{ actie: "toestaan", match: { chatType: "direct" } }],
        },
        modellen: [
          { provider: "openai", model: "gpt-4o-mini-transcribe" },
          { type: "cli", command: "fluister", args: ["--model", "base", "{{MediaPath}}"] },
        ],
      },
      video: {
        ingeschakeld: waar,
        maxBytes: 52428800,
        modellen: [{ provider: "google", model: "gemini-3-flash-preview" }],
      },
    },
  },
}

• model: standaard model voor spawned sub-agents (string of { primary, fallbacks }). Indien weggelaten erft subagenten het model van de caller, tenzij dit wordt overschreven per agent of per oproep.
• maxConcurrent: max gelijktijdige sub-agent draait (standaard 1)
• archiveAfterMinutes: auto-archiveer sub-agent sessies na N minuten (standaard 60; zet 0 om uit te schakelen)
• Functiebeleid Per-subagent: tools.subagents.allow / tools.subagents.tools.deny (geen wins)

• minimal: alleen session_status
• coding: group:fs, group:runtime, group:sessions, group:memory, image
• messaging: group:messaging, sessions_list, sessions_history, sessions_send, session_status
• full: geen beperking (zelfde als niet ingesteld)

{
  tools: {
    profile: "messaging",
    allow: ["slack", "discord"],
  },
}

{
  tools: {
    profile: "coding",
    deny: ["group:runtime"],
  },
}

{
  tools: {
    profile: "coding",
    byProvider: {
      "google-antigravity": { profile: "minimal" },
    },
  },
}

{
  tools: {
    allow: ["group:fs", "group:runtime", "sessions_list"],
    byProvider: {
      "openai/gpt-5.2": { allow: ["group:fs", "sessions_list"] },
    },
  },
}

{
  tools: { deny: ["browser", "canvas"] },
}

• group:runtime: exec, bash, process
• group:fs: read, write, edit, apply_patch
• group:sessions: sessions_list, sessions_history, sessions_send, sessions_spawn, session_status
• group:memory: memory_search, memory_get
• group:web: web_search, web_fetch
• group:ui: browser, canvas
• group:automation: cron, gateway
• group:messaging: message
• group:nodes: nodes
• group:openclaw: alle ingebouwde OpenClaw-tools (sluit provider-plugins uit)

• ingeschakeld: verhoogde modus toestaan (standaard true)
• allowFrom: per-channel allowlists (leeg = uitgeschakeld)
  • whatsapp: E.164 getallen
  • telegram: chat ids of gebruikersnamen
  • discord: user ids of usernames (val terug naar channels.discord.dm.allowFrom indien niet aanwezig)
  • signaal: E.164 getallen
  • imessage: handles/chat ids
  • webchat: sessie ids of gebruikersnamen

{
  hulpmiddelen: {
    hoog: {
      ingeschakeld: waar,
      allowFrom: {
        whatsapp: ["+15555550123"],
        discord: ["steihuis", "1234567890123"],
      },
    },
  },
}

{
  agents: {
    lijst: [
      {
        id: "familie",
        hulpmiddelen: {
          hoog: { enabled: false },
        },
      },
    ],
  },
}

• tools.elevated is de globale baseline. agents.list[].tools.elevated kan alleen verder beperken (beide moeten toestaan).
• `/hooggelegen oplaadstand per sessie sleutel; inlinerichtlijnen zijn van toepassing op één enkel bericht.
• Verhoogd exec draait op de host en bypasses sandboxing.
• Het gereedschapsbeleid is nog steeds van toepassing; als ‘exec’ wordt geweigerd, kan de hoogte niet worden gebruikt.

​

agents.defaults.sandbox

• scope: "agent" (één container + werkruimte per agent)
• Debiaanse boekenworm-slim gebaseerde afbeelding
• agent werkruimte toegang: workspaceAccess: "none" (standaard)
  • "none": gebruik een sandbox werkruimte per bereik onder ~/.openclaw/sandboxes`
• "ro": behoud de sandbox werkruimte op /workspace, en koppel de agent werkruimte read-only op /agent (schakelt write/edit/apply_patch)
  • "rw": mount the agent workspace read/write at at /workspace`
• automatisch opruimen: inactief > 24u OF leeftijd > 7d
• tool policy: alleen exec, process, read, edit, edit, apply_patch, sessions_list, sessions_history, sessions_send, sessions_spawn, sessions_status (deny wins)
  • configureren via tools.sandbox.tools, override per-agent via agents.list[].tools.sandbox.tools
  • tool group shorthands ondersteund in sandbox beleid: group:runtime, group:fs, group:sessions, group:memory (zie Sandbox vs Tool Policy vs Elevated)
• optionele sandboxed browser (Chromium + CDP, noVNC observer)
• hardening knobs: network, user, pidsLimit, memory, cpus, ulimits, seccompProfile, apparmormorProfile

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main", // korting Onafhankelijk van niet-hoofdindex alle
        toepassingsgebied: "agent", // Sessieliemand, gedeeld (agent is standaard)
        workspaceAccess: "geen", // geen ½ ro wwrw
        workspaceRoot: "~/. penclaw/sandboxes",
        docker: {
          image: "openclaw-sandbox:bookworm-slim",
          containerPrefix: "openclaw-sbx-",
          workdir: "/workspace",
          readOnlyRoot: waar,
          tmpfs: ["/tmp", "/var/tmp", "/run"],
          netwerk: "geen",
          gebruiker: "1000:1000",
          capDrop: ["ALL"],
          env: { LANG: "C. TF-8" },
          setupCommand: "apt-get update && apt-get install -y git curl jq",
          // Per-agent overschrijven (multi-agent): agents. ist[].sandbox.docker.
          Pidslimiet: 256,
          geheugen: "1g",
          geheugenSwap: "2g",
          cpus: 1,
          ulimits: {
            nofile: { soft: 1024, hard: 2048 },
            nproc: 256,
          },
          seccompProfile: "/path/to/seccomp. son",
          apmorProfile: "openclaw-sandbox",
          dns: ["1. .1.1", "8.8. "],
          extraHosts: ["internal.service:10.0.0. "],
          binds: ["/var/run/docker.sock:/var/run/docker. ock", "/home/user/source:/source:rw"],
        },
        browser: {
          ingeschakeld: false,
          afbeelding: "openclaw-sandbox-browser:bookworm-slim",
          containerPrefix: "openclaw-sbx-browser-",
          cdpPort: 9222,
          vncPort: 5900,
          noVncPort: 6080,
          hoofdstuk: onjuist,
          enableNoVnc: waar,
          Staat HostControl: false,
          allowedControlUrls: ["http://10. .0.42:18791"],
          allowedControlHosts: ["browser.lab.local", "10.0.0. 2"],
          toegestane Bedieningspoorten: [18791],
          autostart: waar,
          autoStartTimeouts: 12000,
        },
        prune: {
          idleHours: 24, // 0 schakelt inactieve printing
          maxAgeDays: 7, // 0 schakelt max-age pruning
        } uit,
      },
    },
  },
  tools: {
    sandbox: {
      tools: {
        allow: [
          "exec",
          "proces",
          "lezen",
          "schrijven",
          "bewerken",
          "apply_patch",
          "sessions_list",
          "sessions_history",
          "sessions_send",
          "sessions_spawn",
          "session_status",
        ],
        weigering: ["browser", "canvas", "nodes", "cron", "discord", "gateway"],
      },
    },
  },
}