Configuration — agents

Documentation Index

Fetch the complete documentation index at: https://docs2.openclaw.ai/llms.txt

Use this file to discover all available pages before exploring further.

​

Valeurs par défaut des agents

​

agents.defaults.workspace

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

​

agents.defaults.repoRoot

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

​

agents.defaults.skills

{
  agents: {
    defaults: { skills: ["github", "weather"] },
    list: [
      { id: "writer" }, // inherits github, weather
      { id: "docs", skills: ["docs-search"] }, // replaces defaults
      { id: "locked-down", skills: [] }, // no skills
    ],
  },
}

• Omettez agents.defaults.skills pour autoriser les Skills sans restriction par défaut.
• Omettez agents.list[].skills pour hériter des valeurs par défaut.
• Définissez agents.list[].skills: [] pour n’autoriser aucune Skill.
• Une liste non vide agents.list[].skills est l’ensemble final pour cet agent ; elle n’est pas fusionnée avec les valeurs par défaut.

​

agents.defaults.skipBootstrap

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

​

agents.defaults.skipOptionalBootstrapFiles

{
  agents: {
    defaults: {
      skipOptionalBootstrapFiles: ["SOUL.md", "USER.md"],
    },
  },
}

​

agents.defaults.contextInjection

• "continuation-skip" : les tours de continuation sûrs (après une réponse d’assistant terminée) ignorent la réinjection du bootstrap de l’espace de travail, ce qui réduit la taille du prompt. Les exécutions Heartbeat et les nouvelles tentatives après Compaction reconstruisent toujours le contexte.
• "never" : désactive l’injection du bootstrap de l’espace de travail et des fichiers de contexte à chaque tour. Utilisez cette option uniquement pour les agents qui gèrent entièrement le cycle de vie de leur prompt (moteurs de contexte personnalisés, runtimes natifs qui construisent leur propre contexte ou workflows spécialisés sans bootstrap). Les tours Heartbeat et de récupération après Compaction ignorent aussi l’injection.

{
  agents: { defaults: { contextInjection: "continuation-skip" } },
}

​

agents.defaults.bootstrapMaxChars

{
  agents: { defaults: { bootstrapMaxChars: 12000 } },
}

​

agents.defaults.bootstrapTotalMaxChars

{
  agents: { defaults: { bootstrapTotalMaxChars: 60000 } },
}

​

agents.defaults.bootstrapPromptTruncationWarning

• "off" : n’injecte jamais de texte d’avis de troncature dans le prompt système.
• "once" : injecte un avis concis une seule fois par signature de troncature unique (recommandé).
• "always" : injecte un avis concis à chaque exécution lorsqu’une troncature existe.

{
  agents: { defaults: { bootstrapPromptTruncationWarning: "once" } }, // off | once | always
}

​

Carte de propriété des budgets de contexte

• agents.defaults.bootstrapMaxChars / agents.defaults.bootstrapTotalMaxChars : injection normale du bootstrap de l’espace de travail.
• agents.defaults.startupContext.* : préambule ponctuel de lancement/réinitialisation d’exécution du modèle, incluant les fichiers récents quotidiens memory/*.md. Les commandes de chat nues /new et /reset sont acquittées sans invoquer le modèle.
• skills.limits.* : la liste compacte des Skills injectée dans le prompt système.
• agents.defaults.contextLimits.* : extraits runtime bornés et blocs injectés détenus par le runtime.
• memory.qmd.limits.* : extrait de recherche mémoire indexée et dimensionnement d’injection.

• agents.list[].skillsLimits.maxSkillsPromptChars
• agents.list[].contextLimits.*

​

agents.defaults.startupContext

{
  agents: {
    defaults: {
      startupContext: {
        enabled: true,
        applyOn: ["new", "reset"],
        dailyMemoryDays: 2,
        maxFileBytes: 16384,
        maxFileChars: 1200,
        maxTotalChars: 2800,
      },
    },
  },
}

​

agents.defaults.contextLimits

{
  agents: {
    defaults: {
      contextLimits: {
        memoryGetMaxChars: 12000,
        memoryGetDefaultLines: 120,
        toolResultMaxChars: 16000,
        postCompactionMaxChars: 1800,
      },
    },
  },
}

• memoryGetMaxChars : limite d’extrait memory_get par défaut avant l’ajout des métadonnées de troncature et de l’avis de continuation.
• memoryGetDefaultLines : fenêtre de lignes memory_get par défaut lorsque lines est omis.
• toolResultMaxChars : limite des résultats d’outil en direct utilisée pour les résultats persistés et la récupération après dépassement.
• postCompactionMaxChars : limite d’extrait AGENTS.md utilisée lors de l’injection de rafraîchissement après Compaction.

​

agents.list[].contextLimits

{
  agents: {
    defaults: {
      contextLimits: {
        memoryGetMaxChars: 12000,
        toolResultMaxChars: 16000,
      },
    },
    list: [
      {
        id: "tiny-local",
        contextLimits: {
          memoryGetMaxChars: 6000,
          toolResultMaxChars: 8000,
        },
      },
    ],
  },
}

​

skills.limits.maxSkillsPromptChars

{
  skills: {
    limits: {
      maxSkillsPromptChars: 18000,
    },
  },
}

​

agents.list[].skillsLimits.maxSkillsPromptChars

{
  agents: {
    list: [
      {
        id: "tiny-local",
        skillsLimits: {
          maxSkillsPromptChars: 6000,
        },
      },
    ],
  },
}

​

agents.defaults.imageMaxDimensionPx

{
  agents: { defaults: { imageMaxDimensionPx: 1200 } },
}

​

agents.defaults.userTimezone

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

​

agents.defaults.timeFormat

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

​

agents.defaults.model

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-opus-4-6": { alias: "opus" },
        "minimax/MiniMax-M2.7": { alias: "minimax" },
      },
      model: {
        primary: "anthropic/claude-opus-4-6",
        fallbacks: ["minimax/MiniMax-M2.7"],
      },
      imageModel: {
        primary: "openrouter/qwen/qwen-2.5-vl-72b-instruct:free",
        fallbacks: ["openrouter/google/gemini-2.0-flash-vision:free"],
      },
      imageGenerationModel: {
        primary: "openai/gpt-image-2",
        fallbacks: ["google/gemini-3.1-flash-image-preview"],
      },
      videoGenerationModel: {
        primary: "qwen/wan2.6-t2v",
        fallbacks: ["qwen/wan2.6-i2v"],
      },
      pdfModel: {
        primary: "anthropic/claude-opus-4-6",
        fallbacks: ["openai/gpt-5.4-mini"],
      },
      params: { cacheRetention: "long" }, // global default provider params
      pdfMaxBytesMb: 10,
      pdfMaxPages: 20,
      thinkingDefault: "low",
      verboseDefault: "off",
      toolProgressDetail: "explain",
      reasoningDefault: "off",
      elevatedDefault: "on",
      timeoutSeconds: 600,
      mediaMaxMb: 5,
      contextTokens: 200000,
      maxConcurrent: 3,
    },
  },
}

• model : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • La forme chaîne définit uniquement le modèle principal.
  • La forme objet définit le modèle principal ainsi que les modèles de basculement ordonnés.
• imageModel : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • Utilisé par le chemin de l’outil image comme configuration de son modèle de vision.
  • Également utilisé comme routage de secours lorsque le modèle sélectionné/par défaut ne peut pas accepter d’entrée image.
  • Préférez les références explicites provider/model. Les identifiants nus sont acceptés pour compatibilité ; si un identifiant nu correspond de façon unique à une entrée configurée compatible avec les images dans models.providers.*.models, OpenClaw le qualifie avec ce fournisseur. Les correspondances configurées ambiguës nécessitent un préfixe de fournisseur explicite.
• imageGenerationModel : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • Utilisé par la capacité partagée de génération d’images et toute future surface d’outil/plugin qui génère des images.
  • Valeurs typiques : google/gemini-3.1-flash-image-preview pour la génération d’images Gemini native, fal/fal-ai/flux/dev pour fal, openai/gpt-image-2 pour OpenAI Images, ou openai/gpt-image-1.5 pour la sortie OpenAI PNG/WebP avec arrière-plan transparent.
  • Si vous sélectionnez directement un fournisseur/modèle, configurez aussi l’authentification du fournisseur correspondant (par exemple GEMINI_API_KEY ou GOOGLE_API_KEY pour google/*, OPENAI_API_KEY ou OpenAI Codex OAuth pour openai/gpt-image-2 / openai/gpt-image-1.5, FAL_KEY pour fal/*).
  • Si omis, image_generate peut toujours déduire un fournisseur par défaut adossé à une authentification. Il essaie d’abord le fournisseur par défaut actuel, puis les autres fournisseurs de génération d’images enregistrés dans l’ordre des identifiants de fournisseur.
• musicGenerationModel : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • Utilisé par la capacité partagée de génération de musique et l’outil intégré music_generate.
  • Valeurs typiques : google/lyria-3-clip-preview, google/lyria-3-pro-preview ou minimax/music-2.6.
  • Si omis, music_generate peut toujours déduire un fournisseur par défaut adossé à une authentification. Il essaie d’abord le fournisseur par défaut actuel, puis les autres fournisseurs de génération de musique enregistrés dans l’ordre des identifiants de fournisseur.
  • Si vous sélectionnez directement un fournisseur/modèle, configurez aussi l’authentification/la clé d’API du fournisseur correspondant.
• videoGenerationModel : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • Utilisé par la capacité partagée de génération vidéo et l’outil intégré video_generate.
  • Valeurs typiques : qwen/wan2.6-t2v, qwen/wan2.6-i2v, qwen/wan2.6-r2v, qwen/wan2.6-r2v-flash ou qwen/wan2.7-r2v.
  • Si omis, video_generate peut toujours déduire un fournisseur par défaut adossé à une authentification. Il essaie d’abord le fournisseur par défaut actuel, puis les autres fournisseurs de génération vidéo enregistrés dans l’ordre des identifiants de fournisseur.
  • Si vous sélectionnez directement un fournisseur/modèle, configurez aussi l’authentification/la clé d’API du fournisseur correspondant.
  • Le fournisseur intégré de génération vidéo Qwen prend en charge jusqu’à 1 vidéo de sortie, 1 image d’entrée, 4 vidéos d’entrée, une durée de 10 secondes, ainsi que les options de niveau fournisseur size, aspectRatio, resolution, audio et watermark.
• pdfModel : accepte soit une chaîne ("provider/model"), soit un objet ({ primary, fallbacks }).
  • Utilisé par l’outil pdf pour le routage du modèle.
  • Si omis, l’outil PDF se rabat sur imageModel, puis sur le modèle de session/par défaut résolu.
• pdfMaxBytesMb : limite de taille PDF par défaut pour l’outil pdf lorsque maxBytesMb n’est pas passé au moment de l’appel.
• pdfMaxPages : nombre maximal de pages prises en compte par défaut par le mode de secours d’extraction dans l’outil pdf.
• verboseDefault : niveau verbeux par défaut pour les agents. Valeurs : "off", "on", "full". Par défaut : "off".
• toolProgressDetail : mode de détail pour les résumés d’outils /verbose et les lignes d’outils de brouillon de progression. Valeurs : "explain" (par défaut, libellés humains compacts) ou "raw" (ajoute la commande/le détail brut lorsqu’il est disponible). agents.list[].toolProgressDetail par agent remplace cette valeur par défaut.
• reasoningDefault : visibilité du raisonnement par défaut pour les agents. Valeurs : "off", "on", "stream". agents.list[].reasoningDefault par agent remplace cette valeur par défaut. Les valeurs par défaut de raisonnement configurées ne sont appliquées qu’aux propriétaires, expéditeurs autorisés ou contextes Gateway administrateur-opérateur lorsqu’aucun remplacement de raisonnement par message ou par session n’est défini.
• elevatedDefault : niveau de sortie élevée par défaut pour les agents. Valeurs : "off", "on", "ask", "full". Par défaut : "on".
• model.primary : format provider/model (par exemple openai/gpt-5.5 pour un accès par clé d’API OpenAI ou Codex OAuth). Si vous omettez le fournisseur, OpenClaw essaie d’abord un alias, puis une correspondance unique de fournisseur configuré pour cet identifiant exact de modèle, et seulement ensuite se rabat sur le fournisseur par défaut configuré (comportement de compatibilité obsolète ; préférez donc provider/model explicite). Si ce fournisseur n’expose plus le modèle par défaut configuré, OpenClaw se rabat sur le premier fournisseur/modèle configuré au lieu d’exposer une valeur par défaut périmée d’un fournisseur supprimé.
• models : catalogue de modèles configuré et liste d’autorisation pour /model. Chaque entrée peut inclure alias (raccourci) et params (spécifiques au fournisseur, par exemple temperature, maxTokens, cacheRetention, context1m, responsesServerCompaction, responsesCompactThreshold, chat_template_kwargs, extra_body/extraBody).
  • Utilisez des entrées provider/* telles que "openai-codex/*": {} ou "vllm/*": {} pour afficher tous les modèles découverts pour les fournisseurs sélectionnés sans lister manuellement chaque identifiant de modèle.
  • Modifications sûres : utilisez openclaw config set agents.defaults.models '<json>' --strict-json --merge pour ajouter des entrées. config set refuse les remplacements qui supprimeraient des entrées existantes de la liste d’autorisation, sauf si vous passez --replace.
  • Les flux de configuration/d’intégration limités au fournisseur fusionnent les modèles de fournisseur sélectionnés dans cette map et préservent les fournisseurs sans rapport déjà configurés.
  • Pour les modèles OpenAI Responses directs, la Compaction côté serveur est activée automatiquement. Utilisez params.responsesServerCompaction: false pour arrêter l’injection de context_management, ou params.responsesCompactThreshold pour remplacer le seuil. Voir Compaction côté serveur OpenAI.
• params : paramètres globaux par défaut du fournisseur appliqués à tous les modèles. Définis dans agents.defaults.params (par exemple { cacheRetention: "long" }).
• Priorité de fusion de params (configuration) : agents.defaults.params (base globale) est remplacé par agents.defaults.models["provider/model"].params (par modèle), puis agents.list[].params (identifiant d’agent correspondant) remplace par clé. Voir Mise en cache des prompts pour plus de détails.
• params.extra_body/params.extraBody : JSON avancé transmis tel quel et fusionné dans les corps de requête api: "openai-completions" pour les proxys compatibles OpenAI. En cas de collision avec des clés de requête générées, le corps supplémentaire l’emporte ; les routes de complétion non natives suppriment toujours ensuite store, propre à OpenAI.
• params.chat_template_kwargs : arguments de modèle de discussion compatibles vLLM/OpenAI fusionnés dans les corps de requête de niveau supérieur api: "openai-completions". Pour vllm/nemotron-3-* avec la réflexion désactivée, le plugin vLLM intégré envoie automatiquement enable_thinking: false et force_nonempty_content: true ; les chat_template_kwargs explicites remplacent les valeurs par défaut générées, et extra_body.chat_template_kwargs garde la priorité finale. Pour les contrôles de réflexion Qwen vLLM, définissez params.qwenThinkingFormat sur "chat-template" ou "top-level" dans cette entrée de modèle.
• compat.thinkingFormat : style de charge utile de réflexion compatible OpenAI. Utilisez "qwen" pour enable_thinking de niveau supérieur de style Qwen, ou "qwen-chat-template" pour chat_template_kwargs.enable_thinking sur les backends de la famille Qwen qui prennent en charge les kwargs de modèle de discussion au niveau de la requête, comme vLLM. OpenClaw associe la réflexion désactivée à false et la réflexion activée à true.
• compat.supportedReasoningEfforts : liste d’efforts de raisonnement compatibles OpenAI par modèle. Incluez "xhigh" pour les endpoints personnalisés qui l’acceptent réellement ; OpenClaw expose alors /think xhigh dans les menus de commandes, les lignes de session Gateway, la validation des correctifs de session, la validation de la CLI d’agent et la validation llm-task pour ce fournisseur/modèle configuré. Utilisez compat.reasoningEffortMap lorsque le backend attend une valeur propre au fournisseur pour un niveau canonique.
• params.preserveThinking : activation explicite propre à Z.AI pour la réflexion préservée. Lorsque cette option est activée et que la réflexion est active, OpenClaw envoie thinking.clear_thinking: false et rejoue le reasoning_content précédent ; voir Réflexion Z.AI et réflexion préservée.
• localService : gestionnaire de processus facultatif au niveau fournisseur pour les serveurs de modèles locaux/auto-hébergés. Lorsque le modèle sélectionné appartient à ce fournisseur, OpenClaw sonde healthUrl (ou baseUrl + "/models"), démarre command avec args si l’endpoint est indisponible, attend jusqu’à readyTimeoutMs, puis envoie la requête de modèle. command doit être un chemin absolu. idleStopMs: 0 garde le processus actif jusqu’à la fermeture d’OpenClaw ; une valeur positive arrête le processus lancé par OpenClaw après ce nombre de millisecondes d’inactivité. Voir Services de modèles locaux.
• La politique d’exécution appartient aux fournisseurs ou aux modèles, pas à agents.defaults. Utilisez models.providers.<provider>.agentRuntime pour les règles à l’échelle du fournisseur ou agents.defaults.models["provider/model"].agentRuntime / agents.list[].models["provider/model"].agentRuntime pour les règles propres au modèle. Les modèles d’agent OpenAI sur le fournisseur OpenAI officiel sélectionnent Codex par défaut.
• Les rédacteurs de configuration qui modifient ces champs (par exemple /models set, /models set-image et les commandes d’ajout/suppression de secours) enregistrent la forme objet canonique et préservent les listes de secours existantes lorsque c’est possible.
• maxConcurrent : nombre maximal d’exécutions d’agents parallèles entre les sessions (chaque session reste sérialisée). Par défaut : 4.

​

Politique d’exécution

{
  models: {
    providers: {
      openai: {
        agentRuntime: { id: "codex" },
      },
    },
  },
  agents: {
    defaults: {
      model: "openai/gpt-5.5",
      models: {
        "anthropic/claude-opus-4-7": {
          agentRuntime: { id: "claude-cli" },
        },
      },
    },
  },
}

• id : "auto", "pi", un identifiant de harnais de plugin enregistré ou un alias de backend CLI pris en charge. Le plugin Codex intégré enregistre codex ; le plugin Anthropic intégré fournit le backend CLI claude-cli.
• id: "auto" permet aux harnais de plugin enregistrés de réclamer les tours pris en charge et utilise PI lorsqu’aucun harnais ne correspond. Une exécution de plugin explicite comme id: "codex" exige ce harnais et échoue fermement s’il est indisponible ou échoue.
• Les clés d’exécution au niveau de l’agent entier sont héritées. agents.defaults.agentRuntime, agents.list[].agentRuntime, les épingles d’exécution de session et OPENCLAW_AGENT_RUNTIME sont ignorés par la sélection d’exécution. Exécutez openclaw doctor --fix pour supprimer les valeurs obsolètes.
• Les modèles d’agent OpenAI utilisent le harnais Codex par défaut ; agentRuntime.id: "codex" au niveau fournisseur/modèle reste valide lorsque vous voulez le rendre explicite.
• Pour les déploiements Claude CLI, préférez model: "anthropic/claude-opus-4-7" avec agentRuntime.id: "claude-cli" limité au modèle. Les références de modèle héritées claude-cli/claude-opus-4-7 fonctionnent toujours pour compatibilité, mais les nouvelles configurations doivent conserver la sélection fournisseur/modèle canonique et placer le backend d’exécution dans la politique d’exécution fournisseur/modèle.
• Cela ne contrôle que l’exécution des tours d’agent texte. La génération de médias, la vision, PDF, la musique, la vidéo et TTS continuent d’utiliser leurs paramètres fournisseur/modèle.

​

agents.defaults.cliBackends

{
  agents: {
    defaults: {
      cliBackends: {
        "codex-cli": {
          command: "/opt/homebrew/bin/codex",
        },
        "my-cli": {
          command: "my-cli",
          args: ["--json"],
          output: "json",
          modelArg: "--model",
          sessionArg: "--session",
          sessionMode: "existing",
          systemPromptArg: "--system",
          // Or use systemPromptFileArg when the CLI accepts a prompt file flag.
          systemPromptWhen: "first",
          imageArg: "--image",
          imageMode: "repeat",
        },
      },
    },
  },
}

• Les backends CLI donnent la priorité au texte ; les outils sont toujours désactivés.
• Les sessions sont prises en charge lorsque sessionArg est défini.
• La transmission d’images est prise en charge lorsque imageArg accepte les chemins de fichiers.
• reseedFromRawTranscriptWhenUncompacted: true permet à un backend de récupérer des sessions invalidées sûres à partir d’une fin bornée de transcript OpenClaw brut avant que le premier résumé de compaction n’existe. Les changements de profil d’authentification ou d’époque d’identifiants ne relancent toujours jamais depuis le brut.

​

agents.defaults.systemPromptOverride

{
  agents: {
    defaults: {
      systemPromptOverride: "You are a helpful assistant.",
    },
  },
}

​

agents.defaults.promptOverlays

{
  agents: {
    defaults: {
      promptOverlays: {
        gpt5: {
          personality: "friendly", // friendly | on | off
        },
      },
    },
  },
}

• "friendly" (par défaut) et "on" activent la couche conviviale de style d’interaction.
• "off" désactive uniquement la couche conviviale ; le contrat de comportement GPT-5 balisé reste activé.
• L’ancien plugins.entries.openai.config.personality est toujours lu lorsque ce réglage partagé n’est pas défini.

​

agents.defaults.heartbeat

{
  agents: {
    defaults: {
      heartbeat: {
        every: "30m", // 0m disables
        model: "openai/gpt-5.4-mini",
        includeReasoning: false,
        includeSystemPromptSection: true, // default: true; false omits the Heartbeat section from the system prompt
        lightContext: false, // default: false; true keeps only HEARTBEAT.md from workspace bootstrap files
        isolatedSession: false, // default: false; true runs each heartbeat in a fresh session (no conversation history)
        skipWhenBusy: false, // default: false; true also waits for this agent's subagent/nested lanes
        session: "main",
        to: "+15555550123",
        directPolicy: "allow", // allow (default) | block
        target: "none", // default: none | options: last | whatsapp | telegram | discord | ...
        prompt: "Read HEARTBEAT.md if it exists...",
        ackMaxChars: 300,
        suppressToolErrorWarnings: false,
        timeoutSeconds: 45,
      },
    },
  },
}

• every : chaîne de durée (ms/s/m/h). Par défaut : 30m (authentification par clé API) ou 1h (authentification OAuth). Définissez sur 0m pour désactiver.
• includeSystemPromptSection : lorsque la valeur est false, omet la section Heartbeat du prompt système et ignore l’injection de HEARTBEAT.md dans le contexte d’amorçage. Par défaut : true.
• suppressToolErrorWarnings : lorsque la valeur est true, supprime les charges utiles d’avertissement d’erreur d’outil pendant les exécutions Heartbeat.
• timeoutSeconds : durée maximale en secondes autorisée pour un tour d’agent Heartbeat avant son abandon. Laissez non défini pour utiliser agents.defaults.timeoutSeconds.
• directPolicy : politique de livraison directe/DM. allow (par défaut) autorise la livraison à une cible directe. block supprime la livraison à une cible directe et émet reason=dm-blocked.
• lightContext : lorsque la valeur est true, les exécutions Heartbeat utilisent un contexte d’amorçage léger et ne conservent que HEARTBEAT.md parmi les fichiers d’amorçage de l’espace de travail.
• isolatedSession : lorsque la valeur est true, chaque Heartbeat s’exécute dans une nouvelle session sans historique de conversation antérieur. Même modèle d’isolation que cron sessionTarget: "isolated". Réduit le coût en jetons par Heartbeat d’environ 100 000 à environ 2 000-5 000 jetons.
• skipWhenBusy : lorsque la valeur est true, les exécutions Heartbeat sont différées sur les voies d’activité supplémentaires de cet agent : son propre sous-agent indexé par clé de session ou son travail de commande imbriqué. Les voies Cron diffèrent toujours les Heartbeats, même sans cet indicateur.
• Par agent : définissez agents.list[].heartbeat. Lorsqu’un agent définit heartbeat, seuls ces agents exécutent des Heartbeats.
• Les Heartbeats exécutent des tours d’agent complets — des intervalles plus courts consomment davantage de jetons.

​

agents.defaults.compaction

{
  agents: {
    defaults: {
      compaction: {
        mode: "safeguard", // default | safeguard
        provider: "my-provider", // id of a registered compaction provider plugin (optional)
        timeoutSeconds: 900,
        reserveTokensFloor: 24000,
        keepRecentTokens: 50000,
        identifierPolicy: "strict", // strict | off | custom
        identifierInstructions: "Preserve deployment IDs, ticket IDs, and host:port pairs exactly.", // used when identifierPolicy=custom
        qualityGuard: { enabled: true, maxRetries: 1 },
        midTurnPrecheck: { enabled: false }, // optional Pi tool-loop pressure check
        postCompactionSections: ["Session Startup", "Red Lines"], // [] disables reinjection
        model: "openrouter/anthropic/claude-sonnet-4-6", // optional compaction-only model override
        truncateAfterCompaction: true, // rotate to a smaller successor JSONL after compaction
        maxActiveTranscriptBytes: "20mb", // optional preflight local compaction trigger
        notifyUser: true, // send brief notices when compaction starts and completes (default: false)
        memoryFlush: {
          enabled: true,
          model: "ollama/qwen3:8b", // optional memory-flush-only model override
          softThresholdTokens: 6000,
          systemPrompt: "Session nearing compaction. Store durable memories now.",
          prompt: "Write any lasting notes to memory/YYYY-MM-DD.md; reply with the exact silent token NO_REPLY if nothing to store.",
        },
      },
    },
  },
}

• mode : default ou safeguard (résumé par morceaux pour les longs historiques). Consultez Compaction.
• provider : identifiant d’un Plugin fournisseur de Compaction enregistré. Lorsqu’il est défini, le summarize() du fournisseur est appelé à la place du résumé LLM intégré. Se rabat sur l’intégration en cas d’échec. Définir un fournisseur force mode: "safeguard". Consultez Compaction.
• timeoutSeconds : nombre maximal de secondes autorisé pour une opération de Compaction unique avant qu’OpenClaw ne l’abandonne. Par défaut : 900.
• keepRecentTokens : budget de point de coupure Pi pour conserver mot pour mot la fin la plus récente du transcript. /compact manuel respecte ce réglage lorsqu’il est explicitement défini ; sinon, la Compaction manuelle est un point de contrôle strict.
• identifierPolicy : strict (par défaut), off ou custom. strict ajoute en préfixe les instructions intégrées de conservation des identifiants opaques pendant le résumé de Compaction.
• identifierInstructions : texte personnalisé facultatif de préservation des identifiants utilisé lorsque identifierPolicy=custom.
• qualityGuard : vérifications avec nouvelle tentative en cas de sortie mal formée pour les résumés de sauvegarde. Activé par défaut en mode sauvegarde ; définissez enabled: false pour ignorer l’audit.
• midTurnPrecheck : vérification facultative de pression de boucle d’outils Pi. Lorsque enabled: true, OpenClaw vérifie la pression du contexte après l’ajout des résultats d’outils et avant l’appel de modèle suivant. Si le contexte ne tient plus, il abandonne la tentative en cours avant de soumettre le prompt et réutilise le chemin de récupération de pré-vérification existant pour tronquer les résultats d’outils ou compacter puis réessayer. Fonctionne avec les deux modes de Compaction, default et safeguard. Par défaut : désactivé.
• postCompactionSections : noms de sections H2/H3 facultatifs d’AGENTS.md à réinjecter après la Compaction. La valeur par défaut est ["Session Startup", "Red Lines"] ; définissez [] pour désactiver la réinjection. Lorsque le réglage est absent ou explicitement défini sur cette paire par défaut, les anciens titres Every Session/Safety sont aussi acceptés comme repli hérité.
• model : remplacement facultatif provider/model-id pour le résumé de Compaction uniquement. Utilisez-le lorsque la session principale doit conserver un modèle, mais que les résumés de Compaction doivent s’exécuter sur un autre ; lorsqu’il n’est pas défini, la Compaction utilise le modèle principal de la session.
• maxActiveTranscriptBytes : seuil facultatif en octets (number ou chaînes comme "20mb") qui déclenche une Compaction locale normale avant une exécution lorsque le JSONL actif dépasse le seuil. Nécessite truncateAfterCompaction afin qu’une Compaction réussie puisse basculer vers un transcript successeur plus petit. Désactivé lorsque non défini ou 0.
• notifyUser : lorsque true, envoie de brèves notifications à l’utilisateur lorsque la Compaction commence et lorsqu’elle se termine (par exemple, « Compactage du contexte… » et « Compaction terminée »). Désactivé par défaut pour garder la Compaction silencieuse.
• memoryFlush : tour agentique silencieux avant la Compaction automatique pour stocker des mémoires durables. Définissez model sur un fournisseur/modèle exact tel que ollama/qwen3:8b lorsque ce tour de maintenance doit rester sur un modèle local ; le remplacement n’hérite pas de la chaîne de repli de la session active. Ignoré lorsque l’espace de travail est en lecture seule.

​

agents.defaults.runRetries

{
  agents: {
    defaults: {
      runRetries: {
        base: 24,
        perProfile: 8,
        min: 32,
        max: 160,
      },
    },
    list: [
      {
        id: "main",
        runRetries: { max: 50 }, // optional per-agent overrides
      },
    ],
  },
}

• base : nombre de base d’itérations de nouvelle tentative d’exécution pour la boucle d’exécution externe. Par défaut : 24.
• perProfile : itérations de nouvelle tentative d’exécution supplémentaires accordées par profil de repli candidat. Par défaut : 8.
• min : limite absolue minimale pour les itérations de nouvelle tentative d’exécution. Par défaut : 32.
• max : limite absolue maximale pour les itérations de nouvelle tentative d’exécution afin d’éviter une exécution incontrôlée. Par défaut : 160.

​

agents.defaults.contextPruning

{
  agents: {
    defaults: {
      contextPruning: {
        mode: "cache-ttl", // off | cache-ttl
        ttl: "1h", // duration (ms/s/m/h), default unit: minutes
        keepLastAssistants: 3,
        softTrimRatio: 0.3,
        hardClearRatio: 0.5,
        minPrunableToolChars: 50000,
        softTrim: { maxChars: 4000, headChars: 1500, tailChars: 1500 },
        hardClear: { enabled: true, placeholder: "[Old tool result content cleared]" },
        tools: { deny: ["browser", "canvas"] },
      },
    },
  },
}

​

Streaming par blocs

{
  agents: {
    defaults: {
      blockStreamingDefault: "off", // on | off
      blockStreamingBreak: "text_end", // text_end | message_end
      blockStreamingChunk: { minChars: 800, maxChars: 1200 },
      blockStreamingCoalesce: { idleMs: 1000 },
      humanDelay: { mode: "natural" }, // off | natural | custom (use minMs/maxMs)
    },
  },
}

• Les canaux autres que Telegram nécessitent *.blockStreaming: true explicite pour activer les réponses par blocs.
• Remplacements par canal : channels.<channel>.blockStreamingCoalesce (et variantes par compte). Signal/Slack/Discord/Google Chat utilisent par défaut minChars: 1500.
• humanDelay : pause aléatoire entre les réponses par blocs. natural = 800 à 2500 ms. Remplacement par agent : agents.list[].humanDelay.

​

Indicateurs de saisie

{
  agents: {
    defaults: {
      typingMode: "instant", // never | instant | thinking | message
      typingIntervalSeconds: 6,
    },
  },
}

• Valeurs par défaut : instant pour les conversations directes/mentions, message pour les discussions de groupe sans mention.
• Remplacements par session : session.typingMode, session.typingIntervalSeconds.

​

agents.defaults.sandbox

{
  agents: {
    defaults: {
      sandbox: {
        mode: "non-main", // off | non-main | all
        backend: "docker", // docker | ssh | openshell
        scope: "agent", // session | agent | shared
        workspaceAccess: "none", // none | ro | rw
        workspaceRoot: "~/.openclaw/sandboxes",
        docker: {
          image: "openclaw-sandbox:bookworm-slim",
          containerPrefix: "openclaw-sbx-",
          workdir: "/workspace",
          readOnlyRoot: true,
          tmpfs: ["/tmp", "/var/tmp", "/run"],
          network: "none",
          user: "1000:1000",
          capDrop: ["ALL"],
          env: { LANG: "C.UTF-8" },
          setupCommand: "apt-get update && apt-get install -y git curl jq",
          pidsLimit: 256,
          memory: "1g",
          memorySwap: "2g",
          cpus: 1,
          ulimits: {
            nofile: { soft: 1024, hard: 2048 },
            nproc: 256,
          },
          seccompProfile: "/path/to/seccomp.json",
          apparmorProfile: "openclaw-sandbox",
          dns: ["1.1.1.1", "8.8.8.8"],
          extraHosts: ["internal.service:10.0.0.5"],
          binds: ["/home/user/source:/source:rw"],
        },
        ssh: {
          target: "user@gateway-host:22",
          command: "ssh",
          workspaceRoot: "/tmp/openclaw-sandboxes",
          strictHostKeyChecking: true,
          updateHostKeys: true,
          identityFile: "~/.ssh/id_ed25519",
          certificateFile: "~/.ssh/id_ed25519-cert.pub",
          knownHostsFile: "~/.ssh/known_hosts",
          // SecretRefs / inline contents also supported:
          // identityData: { source: "env", provider: "default", id: "SSH_IDENTITY" },
          // certificateData: { source: "env", provider: "default", id: "SSH_CERTIFICATE" },
          // knownHostsData: { source: "env", provider: "default", id: "SSH_KNOWN_HOSTS" },
        },
        browser: {
          enabled: false,
          image: "openclaw-sandbox-browser:bookworm-slim",
          network: "openclaw-sandbox-browser",
          cdpPort: 9222,
          cdpSourceRange: "172.21.0.1/32",
          vncPort: 5900,
          noVncPort: 6080,
          headless: false,
          enableNoVnc: true,
          allowHostControl: false,
          autoStart: true,
          autoStartTimeoutMs: 12000,
        },
        prune: {
          idleHours: 24,
          maxAgeDays: 7,
        },
      },
    },
  },
  tools: {
    sandbox: {
      tools: {
        allow: [
          "exec",
          "process",
          "read",
          "write",
          "edit",
          "apply_patch",
          "sessions_list",
          "sessions_history",
          "sessions_send",
          "sessions_spawn",
          "session_status",
        ],
        deny: ["browser", "canvas", "nodes", "cron", "discord", "gateway"],
      },
    },
  },
}

{
  plugins: {
    entries: {
      openshell: {
        enabled: true,
        config: {
          mode: "mirror", // mirror | remote
          from: "openclaw",
          remoteWorkspaceDir: "/sandbox",
          remoteAgentWorkspaceDir: "/agent",
          gateway: "lab", // optional
          gatewayEndpoint: "https://lab.example", // optional
          policy: "strict", // optional OpenShell policy id
          providers: ["openai"], // optional
          autoProviders: true,
          timeoutSeconds: 120,
        },
      },
    },
  },
}

scripts/sandbox-setup.sh           # main sandbox image
scripts/sandbox-browser-setup.sh   # optional browser image

​

agents.list (remplacements par agent)

{
  agents: {
    list: [
      {
        id: "main",
        default: true,
        name: "Main Agent",
        workspace: "~/.openclaw/workspace",
        agentDir: "~/.openclaw/agents/main/agent",
        model: "anthropic/claude-opus-4-6", // or { primary, fallbacks }
        thinkingDefault: "high", // per-agent thinking level override
        reasoningDefault: "on", // per-agent reasoning visibility override
        fastModeDefault: false, // per-agent fast mode override
        params: { cacheRetention: "none" }, // overrides matching defaults.models params by key
        tts: {
          providers: {
            elevenlabs: { voiceId: "EXAVITQu4vr4xnSDxMaL" },
          },
        },
        skills: ["docs-search"], // replaces agents.defaults.skills when set
        identity: {
          name: "Samantha",
          theme: "helpful sloth",
          emoji: "🦥",
          avatar: "avatars/samantha.png",
        },
        groupChat: { mentionPatterns: ["@openclaw"] },
        sandbox: { mode: "off" },
        runtime: {
          type: "acp",
          acp: {
            agent: "codex",
            backend: "acpx",
            mode: "persistent",
            cwd: "/workspace/openclaw",
          },
        },
        subagents: { allowAgents: ["*"] },
        tools: {
          profile: "coding",
          allow: ["browser"],
          deny: ["canvas"],
          elevated: { enabled: true },
        },
      },
    ],
  },
}

• id : identifiant d’agent stable (obligatoire).
• default : lorsque plusieurs valeurs sont définies, la première l’emporte (un avertissement est journalisé). Si aucune valeur n’est définie, la première entrée de la liste est utilisée par défaut.
• model : la forme chaîne définit un primaire strict par agent sans solution de repli de modèle ; la forme objet { primary } est également stricte sauf si vous ajoutez fallbacks. Utilisez { primary, fallbacks: [...] } pour activer les solutions de repli pour cet agent, ou { primary, fallbacks: [] } pour rendre le comportement strict explicite. Les tâches Cron qui redéfinissent uniquement primary héritent toujours des solutions de repli par défaut, sauf si vous définissez fallbacks: [].
• params : paramètres de flux par agent fusionnés par-dessus l’entrée de modèle sélectionnée dans agents.defaults.models. Utilisez-les pour des redéfinitions propres à l’agent comme cacheRetention, temperature ou maxTokens sans dupliquer tout le catalogue de modèles.
• tts : redéfinitions facultatives de synthèse vocale par agent. Le bloc est fusionné en profondeur par-dessus messages.tts; conservez donc les identifiants de fournisseur partagés et la politique de repli dans messages.tts, puis définissez ici uniquement les valeurs propres à la personnalité, comme le fournisseur, la voix, le modèle, le style ou le mode automatique.
• skills : liste d’autorisation facultative de Skills par agent. Si elle est omise, l’agent hérite de agents.defaults.skills lorsque cette valeur est définie ; une liste explicite remplace les valeurs par défaut au lieu de les fusionner, et [] signifie aucune Skills.
• thinkingDefault : niveau de réflexion par défaut facultatif par agent (off | minimal | low | medium | high | xhigh | adaptive | max). Remplace agents.defaults.thinkingDefault pour cet agent lorsqu’aucune redéfinition par message ou par session n’est définie. Le profil de fournisseur/modèle sélectionné contrôle les valeurs valides ; pour Google Gemini, adaptive conserve la réflexion dynamique gérée par le fournisseur (thinkingLevel omis sur Gemini 3/3.1, thinkingBudget: -1 sur Gemini 2.5).
• reasoningDefault : visibilité du raisonnement par défaut facultative par agent (on | off | stream). Remplace agents.defaults.reasoningDefault pour cet agent lorsqu’aucune redéfinition de raisonnement par message ou par session n’est définie.
• fastModeDefault : valeur par défaut facultative par agent pour le mode rapide (true | false). S’applique lorsqu’aucune redéfinition de mode rapide par message ou par session n’est définie.
• models : redéfinitions facultatives du catalogue de modèles/de l’exécution par agent, indexées par les identifiants complets provider/model. Utilisez models["provider/model"].agentRuntime pour les exceptions d’exécution par agent.
• runtime : descripteur d’exécution facultatif par agent. Utilisez type: "acp" avec les valeurs par défaut de runtime.acp (agent, backend, mode, cwd) lorsque l’agent doit utiliser par défaut des sessions du harnais ACP.
• identity.avatar : chemin relatif à l’espace de travail, URL http(s) ou URI data:.
• identity dérive des valeurs par défaut : ackReaction depuis emoji, mentionPatterns depuis name/emoji.
• subagents.allowAgents : liste d’autorisation des identifiants d’agent pour les cibles explicites sessions_spawn.agentId (["*"] = n’importe lequel ; valeur par défaut : même agent uniquement). Incluez l’identifiant du demandeur lorsque les appels agentId qui se ciblent eux-mêmes doivent être autorisés.
• Garde d’héritage du bac à sable : si la session demandeuse est dans un bac à sable, sessions_spawn rejette les cibles qui s’exécuteraient hors bac à sable.
• subagents.requireAgentId : lorsque cette valeur est vraie, bloque les appels sessions_spawn qui omettent agentId (force la sélection explicite du profil ; valeur par défaut : faux).

​

Routage multi-agent

{
  agents: {
    list: [
      { id: "home", default: true, workspace: "~/.openclaw/workspace-home" },
      { id: "work", workspace: "~/.openclaw/workspace-work" },
    ],
  },
  bindings: [
    { agentId: "home", match: { channel: "whatsapp", accountId: "personal" } },
    { agentId: "work", match: { channel: "whatsapp", accountId: "biz" } },
  ],
}

​

Champs de correspondance des liaisons

• type (facultatif) : route pour le routage normal (un type manquant utilise route par défaut), acp pour les liaisons de conversations ACP persistantes.
• match.channel (obligatoire)
• match.accountId (facultatif ; * = n’importe quel compte ; omis = compte par défaut)
• match.peer (facultatif ; { kind: direct|group|channel, id })
• match.guildId / match.teamId (facultatif ; propre au canal)
• acp (facultatif ; uniquement pour type: "acp") : { mode, label, cwd, backend }

1. match.peer
2. match.guildId
3. match.teamId
4. match.accountId (exact, sans pair/guilde/équipe)
5. match.accountId: "*" (à l’échelle du canal)
6. Agent par défaut

​

Profils d’accès par agent

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

{
  agents: {
    list: [
      {
        id: "family",
        workspace: "~/.openclaw/workspace-family",
        sandbox: { mode: "all", scope: "agent", workspaceAccess: "ro" },
        tools: {
          allow: [
            "read",
            "sessions_list",
            "sessions_history",
            "sessions_send",
            "sessions_spawn",
            "session_status",
          ],
          deny: ["write", "edit", "apply_patch", "exec", "process", "browser"],
        },
      },
    ],
  },
}

{
  agents: {
    list: [
      {
        id: "public",
        workspace: "~/.openclaw/workspace-public",
        sandbox: { mode: "all", scope: "agent", workspaceAccess: "none" },
        tools: {
          allow: [
            "sessions_list",
            "sessions_history",
            "sessions_send",
            "sessions_spawn",
            "session_status",
            "whatsapp",
            "telegram",
            "slack",
            "discord",
            "gateway",
          ],
          deny: [
            "read",
            "write",
            "edit",
            "apply_patch",
            "exec",
            "process",
            "browser",
            "canvas",
            "nodes",
            "cron",
            "gateway",
            "image",
          ],
        },
      },
    ],
  },
}

​

Session

{
  session: {
    scope: "per-sender",
    dmScope: "main", // main | per-peer | per-channel-peer | per-account-channel-peer
    identityLinks: {
      alice: ["telegram:123456789", "discord:987654321012345678"],
    },
    reset: {
      mode: "daily", // daily | idle
      atHour: 4,
      idleMinutes: 60,
    },
    resetByType: {
      thread: { mode: "daily", atHour: 4 },
      direct: { mode: "idle", idleMinutes: 240 },
      group: { mode: "idle", idleMinutes: 120 },
    },
    resetTriggers: ["/new", "/reset"],
    store: "~/.openclaw/agents/{agentId}/sessions/sessions.json",
    maintenance: {
      mode: "warn", // warn | enforce
      pruneAfter: "30d",
      maxEntries: 500,
      resetArchiveRetention: "30d", // duration or false
      maxDiskBytes: "500mb", // optional hard budget
      highWaterBytes: "400mb", // optional cleanup target
    },
    threadBindings: {
      enabled: true,
      idleHours: 24, // default inactivity auto-unfocus in hours (`0` disables)
      maxAgeHours: 0, // default hard max age in hours (`0` disables)
    },
    mainKey: "main", // legacy (runtime always uses "main")
    agentToAgent: { maxPingPongTurns: 5 },
    sendPolicy: {
      rules: [{ action: "deny", match: { channel: "discord", chatType: "group" } }],
      default: "allow",
    },
  },
}

​

Messages

{
  messages: {
    responsePrefix: "🦞", // or "auto"
    ackReaction: "👀",
    ackReactionScope: "group-mentions", // group-mentions | group-all | direct | all
    removeAckAfterReply: false,
    queue: {
      mode: "steer", // steer | queue (legacy one-at-a-time) | followup | collect | steer-backlog | steer+backlog | interrupt
      debounceMs: 500,
      cap: 20,
      drop: "summarize", // old | new | summarize
      byChannel: {
        whatsapp: "steer",
        telegram: "steer",
      },
    },
    inbound: {
      debounceMs: 2000, // 0 disables
      byChannel: {
        whatsapp: 5000,
        slack: 1500,
      },
    },
  },
}

​

Préfixe de réponse

​

Réaction d’accusé de réception

• Par défaut, utilise identity.emoji de l’agent actif, sinon "👀". Définir "" pour désactiver.
• Remplacements par canal : channels.<channel>.ackReaction, channels.<channel>.accounts.<id>.ackReaction.
• Ordre de résolution : compte → canal → messages.ackReaction → repli sur l’identité.
• Portée : group-mentions (par défaut), group-all, direct, all.
• removeAckAfterReply : supprime l’accusé après la réponse sur les canaux prenant en charge les réactions, comme Slack, Discord, Telegram, WhatsApp et iMessage.
• messages.statusReactions.enabled : active les réactions de statut de cycle de vie sur Slack, Discord et Telegram. Sur Slack et Discord, une valeur non définie maintient les réactions de statut activées lorsque les réactions d’accusé sont actives. Sur Telegram, définissez-la explicitement sur true pour activer les réactions de statut de cycle de vie.

​

Anti-rebond entrant

​

TTS (synthèse vocale)

{
  messages: {
    tts: {
      auto: "always", // off | always | inbound | tagged
      mode: "final", // final | all
      provider: "elevenlabs",
      summaryModel: "openai/gpt-4.1-mini",
      modelOverrides: { enabled: true },
      maxTextLength: 4000,
      timeoutMs: 30000,
      prefsPath: "~/.openclaw/settings/tts.json",
      providers: {
        elevenlabs: {
          apiKey: "elevenlabs_api_key",
          baseUrl: "https://api.elevenlabs.io",
          voiceId: "voice_id",
          modelId: "eleven_multilingual_v2",
          seed: 42,
          applyTextNormalization: "auto",
          languageCode: "en",
          voiceSettings: {
            stability: 0.5,
            similarityBoost: 0.75,
            style: 0.0,
            useSpeakerBoost: true,
            speed: 1.0,
          },
        },
        microsoft: {
          voice: "en-US-AvaMultilingualNeural",
          lang: "en-US",
          outputFormat: "audio-24khz-48kbitrate-mono-mp3",
        },
        openai: {
          apiKey: "openai_api_key",
          baseUrl: "https://api.openai.com/v1",
          model: "gpt-4o-mini-tts",
          voice: "alloy",
        },
      },
    },
  },
}

• auto contrôle le mode auto-TTS par défaut : off, always, inbound ou tagged. /tts on|off peut remplacer les préférences locales, et /tts status affiche l’état effectif.
• summaryModel remplace agents.defaults.model.primary pour le résumé automatique.
• modelOverrides est activé par défaut ; modelOverrides.allowProvider vaut false par défaut (activation explicite).
• Les clés API se replient sur ELEVENLABS_API_KEY/XI_API_KEY et OPENAI_API_KEY.
• Les fournisseurs vocaux intégrés appartiennent aux plugins. Si plugins.allow est défini, incluez chaque plugin de fournisseur TTS que vous voulez utiliser, par exemple microsoft pour Edge TTS. L’ancien identifiant de fournisseur edge est accepté comme alias de microsoft.
• providers.openai.baseUrl remplace le point de terminaison OpenAI TTS. L’ordre de résolution est la configuration, puis OPENAI_TTS_BASE_URL, puis https://api.openai.com/v1.
• Lorsque providers.openai.baseUrl pointe vers un point de terminaison non OpenAI, OpenClaw le traite comme un serveur TTS compatible OpenAI et assouplit la validation du modèle/de la voix.

​

Talk

{
  talk: {
    provider: "elevenlabs",
    providers: {
      elevenlabs: {
        voiceId: "elevenlabs_voice_id",
        voiceAliases: {
          Clawd: "EXAVITQu4vr4xnSDxMaL",
          Roger: "CwhRBWXzGAHq8TQ4Fs17",
        },
        modelId: "eleven_v3",
        outputFormat: "mp3_44100_128",
        apiKey: "elevenlabs_api_key",
      },
      mlx: {
        modelId: "mlx-community/Soprano-80M-bf16",
      },
      system: {},
    },
    consultThinkingLevel: "low",
    consultFastMode: true,
    speechLocale: "ru-RU",
    silenceTimeoutMs: 1500,
    interruptOnSpeech: true,
    realtime: {
      provider: "openai",
      providers: {
        openai: {
          model: "gpt-realtime-2",
          voice: "cedar",
        },
      },
      instructions: "Speak warmly and keep answers brief.",
      mode: "realtime",
      transport: "webrtc",
      brain: "agent-consult",
    },
  },
}

• talk.provider doit correspondre à une clé dans talk.providers lorsque plusieurs fournisseurs Talk sont configurés.
• Les anciennes clés Talk plates (talk.voiceId, talk.voiceAliases, talk.modelId, talk.outputFormat, talk.apiKey) sont uniquement destinées à la compatibilité. Exécutez openclaw doctor --fix pour réécrire la configuration persistée vers talk.providers.<provider>.
• Les identifiants de voix se replient sur ELEVENLABS_VOICE_ID ou SAG_VOICE_ID.
• providers.*.apiKey accepte les chaînes en clair ou les objets SecretRef.
• Le repli ELEVENLABS_API_KEY ne s’applique que lorsqu’aucune clé API Talk n’est configurée.
• providers.*.voiceAliases permet aux directives Talk d’utiliser des noms conviviaux.
• providers.mlx.modelId sélectionne le dépôt Hugging Face utilisé par l’assistant MLX local macOS. S’il est omis, macOS utilise mlx-community/Soprano-80M-bf16.
• La lecture macOS MLX passe par l’assistant intégré openclaw-mlx-tts lorsqu’il est présent, ou par un exécutable sur PATH ; OPENCLAW_MLX_TTS_BIN remplace le chemin de l’assistant pour le développement.
• consultThinkingLevel contrôle le niveau de réflexion pour l’exécution complète de l’agent OpenClaw derrière les appels openclaw_agent_consult en temps réel de Control UI Talk. Laissez non défini pour préserver le comportement normal de session/modèle.
• consultFastMode définit un remplacement ponctuel du mode rapide pour les consultations en temps réel Control UI Talk sans modifier le paramètre de mode rapide normal de la session.
• speechLocale définit l’identifiant de locale BCP 47 utilisé par la reconnaissance vocale Talk iOS/macOS. Laissez non défini pour utiliser la valeur par défaut de l’appareil.
• silenceTimeoutMs contrôle la durée pendant laquelle le mode Talk attend après le silence de l’utilisateur avant d’envoyer la transcription. Une valeur non définie conserve la fenêtre de pause par défaut de la plateforme (700 ms on macOS and Android, 900 ms on iOS).
• realtime.instructions ajoute des instructions système destinées au fournisseur au prompt en temps réel intégré d’OpenClaw, afin que le style vocal puisse être configuré sans perdre le guidage par défaut de openclaw_agent_consult.

​

Associés

• Référence de configuration — toutes les autres clés de configuration
• Configuration — tâches courantes et configuration rapide
• Exemples de configuration