# Bien configurer OpenClaw : modèle, Telegram, sécurité

> Régler OpenClaw dans openclaw.json : modèle en ligne ou local, Telegram, mémoire, skills, automatisations, MCP, exécution, bac à sable et service.

- Niveau : Expert
- Thème : Agents et automatisation
- Durée : 22 minutes
- Systèmes : Mac, Windows, Linux
- Disponible en France : Logiciel libre sous licence MIT, à installer soi-même, sans restriction de pays. Documentation en anglais ; le modèle et la messagerie branchés gardent leurs propres conditions. (https://github.com/openclaw/openclaw, lue le 19 novembre 2026)
- Publié le 19 novembre 2026, relu le 19 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/openclaw-configuration/

Le guide [Hermes Agent et OpenClaw](https://quelleia.com/guides/hermes-et-openclaw/) présente ces deux agents personnels libres et leur architecture. Celui-ci entre dans les réglages d'OpenClaw, l'agent tenu par l'OpenClaw Foundation : le fichier de configuration, le choix du modèle, Telegram, puis les couches de sécurité, dont la plus importante reste ouverte par défaut. Tout vient de la documentation officielle lue le 19 novembre 2026, pour la version 2026.11.5 ; les clés et les commandes restent en anglais, comme dans le logiciel.

## Installer et lancer une première fois

OpenClaw demande Node.js 24.16 ou plus récent sur la branche 24, ou 26.1 et plus ; la documentation recommande Node 26. Le script d'installation installe Node si besoin, puis OpenClaw, puis lance la configuration guidée :

**Installer OpenClaw**

macOS, Linux, WSL2 :

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

D'après https://docs.openclaw.ai/install (lue le 3 octobre 2026).

1. Choisissez **Quick start** si vous avez déjà une connexion à Claude Code ou Codex, ou une clé d'API : OpenClaw la détecte, la vérifie par une vraie réponse et ouvre le tableau de bord. **Custom setup** passe par toutes les étapes ; `openclaw configure` y revient plus tard.
2. À la question qui propose de garder OpenClaw en arrière-plan (« Keep OpenClaw running in the background »), répondez oui, ou installez le service vous-même ensuite (plus bas).
3. Vérifiez : `openclaw gateway status` doit montrer la passerelle à l'écoute sur le port 18789, et `openclaw dashboard` ouvre l'interface web (Control UI).

Sous Windows, la documentation recommande l'appli Windows Hub ; sur Mac, l'appli de la barre des menus. Les deux savent installer une passerelle locale ou se relier à une passerelle distante, par exemple celle d'un mini-PC toujours allumé.

## Où sont les réglages

Toute la configuration tient dans un fichier, `~/.openclaw/openclaw.json`, écrit en JSON5 (commentaires et virgules finales admis). Sans fichier, OpenClaw prend des valeurs sûres. La configuration minimale de la documentation :

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

Quatre façons de la modifier, qui écrivent toutes dans ce fichier : `openclaw onboard` ou `openclaw configure` (assistants), `openclaw config get|set|unset` (une valeur), l'onglet **Config** du tableau de bord, ou l'édition directe. La passerelle surveille le fichier et applique la plupart des changements sans redémarrage.

![Documentation d'OpenClaw, page Configuration : section Minimal config avec un bloc JSON5 qui fixe le dossier de travail de l'agent et une liste allowFrom pour WhatsApp, puis la section Editing config avec openclaw onboard, openclaw configure et des exemples openclaw config get, set et unset.](https://quelleia.com/guides/openclaw-configuration/config-minimale.webp)

*La page Configuration de la documentation d'OpenClaw, en anglais : la configuration minimale en JSON5 dans ~/.openclaw/openclaw.json, puis les commandes openclaw onboard, configure et config (capture du 19 novembre 2026, docs.openclaw.ai).*

**La validation est stricte.** Une clé inconnue, un type faux ou une valeur hors liste, et la passerelle refuse de démarrer (code de sortie 78). Seules les commandes de diagnostic marchent alors : `openclaw doctor` dit ce qui cloche, `openclaw doctor --fix` répare les anciennes clés et peut restaurer la dernière configuration saine. Une modification à chaud invalide est simplement ignorée : la passerelle garde la configuration précédente. `openclaw config schema` affiche le schéma complet.

À côté du fichier, `~/.openclaw/` garde l'état : identifiants, sessions, bases SQLite par agent, compétences partagées. L'**espace de travail** (`~/.openclaw/workspace` par défaut) est le dossier de l'agent, avec ses fichiers Markdown :

- **`AGENTS.md`** : les consignes de fonctionnement, lues à chaque session ;
- **`SOUL.md`** : personnalité, ton et limites ;
- **`USER.md`** : vos préférences, écrites comme des consignes ;
- **`IDENTITY.md`** : le nom et l'allure de l'agent ;
- **`MEMORY.md`** et **`memory/AAAA-MM-JJ.md`** : la mémoire longue et le journal du jour ;
- **`skills/`** : les compétences propres à cet espace.

La documentation conseille de versionner cet espace dans un dépôt Git privé, et de garder `~/.openclaw/` hors de ce dépôt.

> **Bon à savoir.** L'espace de travail est le dossier courant de l'agent, rien de plus. Sans bac à sable, un chemin absolu atteint le reste de la machine.

## Les secrets

OpenClaw lit les variables de son processus, puis un `.env` du dossier courant et `~/.openclaw/.env` ; aucun des deux n'écrase une variable déjà posée. Dans le fichier de configuration, une valeur peut renvoyer à une variable avec `${NOM}` (noms en capitales seulement) :

```json5
{
  gateway: { auth: { token: "${OPENCLAW_GATEWAY_TOKEN}" } },
  models: { providers: { custom: { apiKey: "${CUSTOM_API_KEY}" } } },
}
```

Pour aller plus loin, les champs qui l'acceptent prennent une référence de secret (`source: "env"`, `"file"` ou `"exec"`, ce dernier pour un coffre comme Vault). Gardez ainsi `openclaw.json` sans aucune clé en clair : vous pouvez le relire, le comparer ou le copier sans risque.

## Choisir le modèle

Les modèles s'écrivent `fournisseur/modèle`. Le modèle principal et ses secours se règlent pour tous les agents :

```json5
{
  agents: {
    defaults: {
      model: {
        primary: "anthropic/claude-sonnet-4-6",
        fallbacks: ["openai/gpt-5.4"],
      },
      models: {
        "anthropic/claude-sonnet-4-6": { alias: "Sonnet" },
        "openai/gpt-5.4": { alias: "GPT" },
      },
    },
  },
}
```

`openclaw models list` montre ce qui est disponible, `openclaw models set <fournisseur/modèle>` change le modèle principal, `/model` le change en conversation. `agents.defaults.modelPolicy.allow` limite les modèles qu'on peut choisir, utile sur une passerelle partagée.

**OpenRouter.** `openclaw onboard --auth-choice openrouter-oauth` passe par une connexion dans le navigateur, `--auth-choice openrouter-api-key` par une clé créée sur openrouter.ai. L'assistant choisit `openrouter/auto` ; fixez ensuite un modèle précis avec `openclaw models set openrouter/<fournisseur>/<modèle>`.

**Ollama, en local.** Le plus simple : `openclaw onboard`, puis **Ollama** et **Local only**. La détection automatique ne retient que les modèles déjà chargés en mémoire, capables d'appeler des outils et ouverts à 16 000 jetons de contexte au moins. Sans assistant :

```bash
ollama pull gemma4
export OLLAMA_API_KEY="ollama-local"     # toute valeur convient pour un Ollama local
openclaw models set ollama/gemma4
```

Pour une autre machine du réseau ou des réglages par modèle, déclarez le fournisseur :

```json5
{
  models: {
    providers: {
      ollama: {
        apiKey: "ollama-local",
        baseUrl: "http://ollama-host:11434", // No /v1 - native Ollama API URL
        api: "ollama",
        timeoutSeconds: 300,
        models: [
          { id: "qwen3:32b", name: "qwen3:32b", params: { keep_alive: "15m" } },
        ],
      },
    },
  },
}
```

Attention à l'adresse : **sans `/v1`**. Avec `/v1`, OpenClaw passe par la compatibilité OpenAI d'Ollama, où l'appel d'outils n'est pas fiable d'après la documentation. C'est l'inverse de Hermes Agent, qui veut l'adresse en `/v1`.

**LM Studio, llama.cpp, vLLM.** LM Studio se déclare avec `api: "openai-responses"` sur `http://127.0.0.1:1234/v1` ; les autres serveurs compatibles OpenAI avec `api: "openai-completions"`. Pour un modèle local, la documentation insiste : prévoyez la place de l'invite complète, des outils et de l'historique, et testez de vraies tâches avant d'en faire le modèle par défaut. Elle conseille aussi de garder `models.mode: "merge"` pour que les modèles en ligne restent disponibles en secours.

**Unsloth Desktop, en local.** Unsloth Desktop sert ses modèles chargés, ceux du NPU des Ryzen AI compris (voir le [guide sur le NPU](https://quelleia.com/guides/npu-ia-locale/)), par une API compatible Anthropic. Le plus court : avec un modèle chargé dans Unsloth, `unsloth start openclaw` lance OpenClaw dans un environnement à part, déjà réglé, sans toucher à votre configuration. À la main, la documentation d'Unsloth ajoute un fournisseur dans `~/.openclaw/openclaw.json` :

```json
{
  "models": {
    "mode": "merge",
    "providers": {
      "unsloth": {
        "baseUrl": "http://localhost:8888",
        "apiKey": "sk-unsloth-xxxxxxxxxxxx",
        "api": "anthropic-messages",
        "models": [
          { "id": "unsloth/Qwen3.6-27B-GGUF", "name": "unsloth/Qwen3.6-27B-GGUF" }
        ],
        "authHeader": true
      }
    }
  }
}
```

La clé se crée dans Unsloth (avatar en bas à gauche, **Settings**, **API**) et ne s'affiche qu'une fois. L'adresse se donne **sans `/v1`** : le kit d'Anthropic ajoute lui-même `/v1/messages`. Le nom du modèle est celui que renvoie `GET /v1/models` (pour le NPU, par exemple `Qwen3.6-35B-A3B-NPU2`). Servez le modèle avec `unsloth run --disable-tools` : sans cette option, Unsloth exécute ses propres outils, et OpenClaw répond sans jamais modifier un fichier.

> **WSL2 et carte NVIDIA.** Le service Ollama installé dans WSL2 redémarre toujours (`Restart=always`) et peut recharger un modèle au démarrage de WSL2 jusqu'à faire tomber la machine virtuelle en boucle. La documentation propose `sudo systemctl disable ollama` et de lancer Ollama à la main.

Les modèles ouverts qui tiennent dans 64 Go de mémoire, d'après le classement de QUELLE IA :

**Les meilleurs modèles pour une machine de 64 Go**

1. [Qwen 3.8 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (allégée à 8 bits, 32,6 Go)
2. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (allégée à 8 bits, 37,4 Go)
3. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (allégée à 8 bits, 33,5 Go)
4. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (allégée à 8 bits, 36,2 Go)
5. [Gemma 4 26B A4B](https://quelleia.com/modeles/gemma-4-26b-a4b/) : score 73,1 (allégée à 8 bits, 31,4 Go)

Mémoire utile retenue : 48 Go, celle des machines suivies de 64 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
[Quel modèle sur ma machine](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

## Brancher Telegram

1. Créez le bot chez **@BotFather** (`/newbot`) et gardez le jeton.
2. Donnez-le à OpenClaw : `openclaw channels add --channel telegram --token <jeton-du-bot>`. Telegram n'utilise pas `openclaw channels login`.
3. Vérifiez : `openclaw channels status --probe`.
4. Écrivez au bot. Votre premier message crée une demande d'appairage : `openclaw pairing list telegram`, puis `openclaw pairing approve telegram <code>`. Les codes expirent au bout d'une heure, et la réponse d'appairage affiche votre identifiant Telegram numérique.

![Documentation d'OpenClaw, page Telegram setup, étape Configure token and DM policy : la commande openclaw channels add --channel telegram --token, puis un bloc JSON5 channels.telegram avec enabled, botToken d'exemple, dmPolicy pairing et groups avec requireMention.](https://quelleia.com/guides/openclaw-configuration/telegram-jeton.webp)

*La page Telegram setup : le jeton se donne par openclaw channels add ou dans openclaw.json, avec la politique des messages privés en pairing (capture du 19 novembre 2026, docs.openclaw.ai).*

Pour un bot qui ne sert que vous, la documentation recommande une liste explicite plutôt que l'appairage seul :

```json5
{
  channels: {
    telegram: {
      enabled: true,
      dmPolicy: "allowlist",
      allowFrom: ["<votre identifiant numérique>"],
      groups: { "*": { requireMention: true } },
    },
  },
}
```

`dmPolicy` accepte `pairing` (par défaut), `allowlist`, `open` et `disabled`. `open` avec `allowFrom: ["*"]` laisse n'importe quel compte qui devine le nom du bot lui donner des ordres. Le jeton se lit dans cet ordre : `tokenFile`, puis `botToken`, puis la variable `TELEGRAM_BOT_TOKEN` ; préférez `tokenFile`, qui garde le jeton hors du fichier de configuration.

Dans un groupe, le bot ne répond qu'aux mentions (`requireMention`), et un groupe doit figurer dans `channels.telegram.groups` (son identifiant commence par `-100`). Pour qu'il voie tous les messages, désactivez le mode « Group Privacy » chez BotFather, puis retirez le bot du groupe et ajoutez-le de nouveau.

> **Quand vous arrêtez.** Désinstaller OpenClaw ne coupe pas le bot : son jeton reste valable. Sur la machine de QUELLE IA, un jeton partagé avec un autre programme est resté actif après le retrait. Révoquez-le chez BotFather (`/revoke`) et faites le tour des appairages avec `openclaw pairing list`.

## Mémoire et compétences

La mémoire d'OpenClaw est faite de fichiers Markdown dans l'espace de travail, sans état caché : `USER.md` et `MEMORY.md` se chargent au début de chaque session, le journal du jour et de la veille sur un `/new`. Pour qu'il retienne quelque chose, dites-le-lui (« retiens que… ») ; vous pouvez aussi éditer ces fichiers vous-même, dans le tableau de bord (**Settings, Agents, Files**) ou dans un éditeur.

Les compétences sont des dossiers avec un `SKILL.md`. Celles de l'espace de travail l'emportent sur toutes les autres, puis viennent `<espace>/.agents/skills`, `~/.agents/skills`, `~/.openclaw/skills` (partagées entre agents), celles que l'agent apprend lui-même (« Skill Workshop ») et celles fournies avec OpenClaw. Le catalogue public s'appelle ClawHub :

```bash
openclaw skills install @owner/<slug>          # dans l'espace de travail
openclaw skills install @owner/<slug> --global # pour tous les agents locaux
openclaw skills verify @owner/<slug>           # vérifie l'origine auprès de ClawHub
openclaw skills update --all
```

Pour limiter les compétences d'un agent, `agents.defaults.skills` fixe une liste commune et `agents.entries.<id>.skills` la remplace ; une liste vide n'en laisse aucune.

## Automatisations

Les tâches planifiées s'appellent « Automations » (`openclaw automations`, ou `openclaw cron`, même commande). L'exemple de la documentation pour un résumé chaque matin, ici réglé sur l'heure de Paris et envoyé sur Telegram :

```bash
openclaw automations create "0 7 * * *" \
  "Summarize overnight updates." \
  --name "Morning brief" \
  --tz "Europe/Paris" \
  --session isolated \
  --announce \
  --channel telegram \
  --to "<votre identifiant numérique>"
```

`--session isolated` lance chaque exécution dans une session neuve. `--model` et `--thinking` fixent un modèle et un effort pour cette seule tâche : de quoi confier les tâches de fond à un modèle moins cher. Pour une simple vérification, `--command` lance une commande ou un script au lieu d'un tour d'agent. `openclaw automations list` et `openclaw automations runs <id>` montrent les tâches et leur historique.

> **Bon à savoir.** Supprimer une conversation ne supprime pas les automatisations qu'elle a créées : une tâche à commande peut continuer de tourner. Faites le tour avec `openclaw automations list --all`.

## Brancher des serveurs MCP

```bash
openclaw mcp add local-tools \
  --command node \
  --arg ./dist/mcp-server.js \
  --cwd /srv/openclaw-tools
openclaw mcp add docs \
  --url https://mcp.example.com/mcp \
  --transport streamable-http \
  --include 'search,read_*'
openclaw mcp doctor docs --probe
```

Enregistrer un serveur ne prouve pas qu'il répond : `openclaw mcp doctor <nom> --probe` le vérifie. Dans le fichier, la même déclaration va sous `mcp.servers`, avec `toolFilter.include` pour ne garder que les outils voulus. Le tableau de bord le fait aussi (**Settings, MCP**), et pour une seule conversation, **+ puis Plugins puis Tool access** retire des outils.

## Permissions et exécution

C'est le réglage à changer en premier. D'après la page Exec tool, **l'exécution de commandes sur la passerelle est autorisée sans question par défaut** (mode `full`), et le bac à sable est désactivé. Le mode se règle dans `tools.exec.mode` :

![Les contrôles qu'un message traverse avant qu'OpenClaw lance une commande sur la machine, d'après les pages Security, Sandboxing et Permission modes de la documentation, lues le 19 novembre 2026.](https://quelleia.com/guides/openclaw-configuration/couches-de-securite.svg)

*Les contrôles qu'un message traverse avant qu'OpenClaw lance une commande sur la machine, d'après les pages Security, Sandboxing et Permission modes de la documentation, lues le 19 novembre 2026.*

- **`deny`** bloque toute commande sur la machine ;
- **`allowlist`** ne lance que les commandes de la liste et refuse le reste en silence ;
- **`ask`** lance les commandes de la liste et vous demande les autres ;
- **`auto`** fait la même chose, avec une relecture automatique avant de vous solliciter ; c'est le mode que la documentation conseille pour un agent de code ;
- **`full`** lance tout sans question.

```bash
openclaw config set tools.exec.mode auto
openclaw approvals get
openclaw gateway restart
openclaw exec-policy show
```

![Documentation d'OpenClaw, page Permission modes : tableau à quatre colonnes Mode, security / ask, Behavior et Use when, avec les lignes deny, allowlist, ask, auto et full.](https://quelleia.com/guides/openclaw-configuration/modes-exec.webp)

*Le tableau des modes d'exécution de la page Permission modes : de deny, qui bloque tout, à full, qui ne pose aucune question (capture du 19 novembre 2026, docs.openclaw.ai).*

`openclaw approvals get` montre la politique demandée, ses sources et le résultat effectif : la règle la plus stricte entre la configuration et le fichier d'approbations de la machine l'emporte. Les validations arrivent dans la conversation ; sans interface pour répondre, la demande est refusée.

Les autres couches :

- **Le profil d'outils** (`tools.profile` : `minimal`, `coding`, `messaging`, `full`) et `tools.deny` retirent des outils. Pour un agent qui lit des pages web ou des e-mails, la page des permissions conseille d'interdire `gateway`, `cron`, `sessions_spawn` et `sessions_send`.
- **`tools.fs.workspaceOnly: true`** cantonne les outils de fichiers à l'espace de travail.
- **Le bac à sable** fait tourner les outils dans un conteneur Docker ou Podman : `agents.defaults.sandbox.mode` vaut `off` (par défaut), `non-main` (tout sauf la session principale) ou `all`. Construisez l'image d'abord (voir Sandboxing) ; `openclaw sandbox explain` dit ce qui est réellement isolé.
- **`tools.elevated`** permet de sortir du bac à sable : laissez-le à `enabled: false`.
- **Les messages entre conversations** : par défaut, un agent peut écrire dans une autre conversation ou sur une autre messagerie. Passez `tools.message.crossContext.allowWithinProvider` et `allowAcrossProviders` à `false` pour le cantonner à la conversation en cours.

## Durcir l'installation

La documentation donne un socle durci à copier, qui garde la passerelle locale, isole les messages privés et coupe l'exécution :

```json5
{
  gateway: {
    mode: "local",
    bind: "loopback",
    auth: { mode: "token", token: "replace-with-long-random-token" },
  },
  session: {
    dmScope: "per-channel-peer",
  },
  tools: {
    profile: "messaging",
    deny: ["group:automation", "group:runtime", "group:fs", "sessions_spawn", "sessions_send"],
    fs: { workspaceOnly: true },
    exec: { security: "deny", ask: "always" },
    elevated: { enabled: false },
    sessions: { visibility: "agent" },
    agentToAgent: { enabled: false },
  },
  channels: {
    whatsapp: { dmPolicy: "pairing", groups: { "*": { requireMention: true } } },
  },
}
```

Partez de là et rouvrez les outils un par un, agent par agent. Remplacez le jeton par une longue valeur aléatoire (par exemple `openssl rand -hex 32`), rangée dans une variable et appelée par `${OPENCLAW_GATEWAY_TOKEN}`.

![Documentation d'OpenClaw, page Hardened baselines : bloc JSON5 avec gateway en mode local, bind loopback et auth par jeton, session dmScope per-channel-peer, tools avec profile messaging, une liste deny, fs workspaceOnly, exec security deny et ask always, elevated désactivé, et WhatsApp en dmPolicy pairing.](https://quelleia.com/guides/openclaw-configuration/socle-durci.webp)

*Le socle durci que propose la page Hardened baselines : passerelle locale avec jeton, messages privés isolés, outils réduits au profil messaging, exécution refusée (capture du 19 novembre 2026, docs.openclaw.ai).*

Ensuite :

1. **`openclaw security audit`** (et `--deep`) passe la configuration en revue et signale tout écart aux valeurs sûres.
2. **Une passerelle par cercle de confiance.** OpenClaw ne sépare pas des utilisateurs qui se méfient les uns des autres : donnez-leur chacun leur passerelle, leurs identifiants et, de préférence, leur compte système.
3. **Un numéro à part** pour les messageries par téléphone (WhatsApp, Signal), que la documentation recommande pour garder vos conversations personnelles hors de portée de l'agent.
4. **Pas d'exposition directe.** Pour joindre la passerelle de l'extérieur, la documentation décrit Tailscale ou un proxy inverse, avec une liste de contrôle avant toute ouverture au-delà de la machine locale.

## Faire tourner en service

```bash
openclaw gateway install      # LaunchAgent (macOS), service utilisateur systemd (Linux, WSL2), tâche planifiée (Windows)
openclaw gateway start        # attend que la passerelle soit prête
openclaw gateway status
sudo loginctl enable-linger $(whoami)   # Linux : le service survit à la déconnexion
```

Sur un serveur sans session graphique, la documentation demande aussi `export XDG_RUNTIME_DIR=/run/user/$(id -u)` avant les commandes `systemctl --user`. Le service s'appelle `openclaw-gateway` (suivi du nom du profil pour un profil nommé), et `ai.openclaw.gateway` sous macOS.

## Mettre à jour et sauvegarder

```bash
openclaw backup create --verify   # config, identifiants, sessions et espaces de travail
openclaw update                   # détecte npm, pnpm, Bun ou Git, vérifie, active
openclaw update status
openclaw doctor
```

`openclaw update` vérifie la nouvelle version pendant que l'ancienne tourne encore, puis l'active et redémarre le service. Il refuse de commencer si le Node du service est trop ancien, et le dit en une ligne. Un `npm install -g openclaw` à la main peut installer une seconde copie que le service n'utilise pas : `openclaw gateway status` montre la version réellement servie. Les canaux `beta` et `dev` se choisissent avec `--channel`.

## Ce que ça coûte

OpenClaw est gratuit. Vous payez le modèle, à l'usage, et la machine qui reste allumée. Les leviers : un modèle principal raisonnable et un plus fort en secours, un modèle local en premier avec un modèle en ligne derrière (`fallbacks`), un modèle moins cher pour les automatisations (`--model`), et des outils réduits au nécessaire, car chaque outil déclaré allonge l'invite envoyée à chaque appel.

## Les erreurs fréquentes

D'abord, l'échelle de diagnostic de la documentation, dans cet ordre :

```bash
openclaw status
openclaw gateway status
openclaw logs --follow
openclaw doctor
openclaw channels status --probe
```

- **La passerelle refuse de démarrer après une modification** : clé inconnue ou valeur invalide. `openclaw doctor`, puis `openclaw doctor --fix`.
- **Le modèle Ollama discute mais n'appelle aucun outil** : l'adresse se termine par `/v1`. Retirez-le et gardez `api: "ollama"`.
- **Le serveur local répond à curl mais l'agent échoue** : identifiant du modèle différent de celui du serveur, ou serveur qui refuse le contenu structuré (`compat.requiresStringContent: true` sur le modèle). Testez avec `openclaw infer model run --model <fournisseur/modèle> --prompt "hi" --json`.
- **« getMe returned 401 » au démarrage** : jeton Telegram faux ou révoqué. Recopiez-le depuis BotFather.
- **Le bot ignore un groupe** : groupe absent de `channels.telegram.groups`, mention manquante, ou mode « Group Privacy » encore actif.
- **`dmPolicy: "allowlist"` rejeté** : la liste `allowFrom` est vide. Ajoutez votre identifiant numérique ; un nom d'utilisateur ne marche pas.
- **`systemctl --user` échoue sur un serveur** : pas de session utilisateur. Activez le « linger » et posez `XDG_RUNTIME_DIR`.

Pour Hermes Agent, l'autre agent personnel libre, voyez [Bien configurer Hermes Agent](https://quelleia.com/guides/hermes-agent-configuration/).

## Pour aller plus loin

- [OpenClaw](https://quelleia.com/outils/openclaw/)
- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Un agent personnel à installer](https://quelleia.com/logitheque/usages/agents-personnels/)
- [Bien configurer Hermes Agent : modèle, Telegram, sécurité](https://quelleia.com/guides/hermes-agent-configuration.md) (guide, expert)
- [Hermes Agent et OpenClaw : les agents personnels libres](https://quelleia.com/guides/hermes-et-openclaw.md) (guide, expert)
- [Le NPU de votre PC : à quoi il sert pour l'IA locale](https://quelleia.com/guides/npu-ia-locale.md) (guide, amateur)
- [MCP : brancher des outils dans Claude, ChatGPT ou un agent](https://quelleia.com/guides/mcp.md) (guide, amateur)
- [Skills, plugins, extensions : enrichir son agent de code](https://quelleia.com/guides/skills-et-plugins.md) (guide, expert)
- [Sur mini lab AI](https://minilabai.com/guides/hermes-openclaw/) : un guide du même auteur, qui va plus loin

## Sources

- https://github.com/openclaw/openclaw (lue le 19 novembre 2026)
- https://docs.openclaw.ai/install (lue le 19 novembre 2026)
- https://docs.openclaw.ai/start/getting-started (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/configuration (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/configuration/common-tasks (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/configuration/environment-variables (lue le 19 novembre 2026)
- https://docs.openclaw.ai/providers/openrouter (lue le 19 novembre 2026)
- https://docs.openclaw.ai/providers/ollama/setup (lue le 19 novembre 2026)
- https://docs.openclaw.ai/providers/ollama/configuration (lue le 19 novembre 2026)
- https://unsloth.ai/docs/integrations/openclaw (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/local-models (lue le 19 novembre 2026)
- https://docs.openclaw.ai/channels/telegram/setup (lue le 19 novembre 2026)
- https://docs.openclaw.ai/channels/telegram/access-control (lue le 19 novembre 2026)
- https://docs.openclaw.ai/concepts/agent-workspace (lue le 19 novembre 2026)
- https://docs.openclaw.ai/concepts/memory (lue le 19 novembre 2026)
- https://docs.openclaw.ai/tools/skills (lue le 19 novembre 2026)
- https://docs.openclaw.ai/automation/cron-jobs/managing-jobs (lue le 19 novembre 2026)
- https://docs.openclaw.ai/tools/mcp (lue le 19 novembre 2026)
- https://docs.openclaw.ai/tools/permission-modes (lue le 19 novembre 2026)
- https://docs.openclaw.ai/tools/exec (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/sandboxing (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/security/hardened-baseline (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/security/tool-permissions (lue le 19 novembre 2026)
- https://docs.openclaw.ai/install/updating (lue le 19 novembre 2026)
- https://docs.openclaw.ai/gateway/troubleshooting (lue le 19 novembre 2026)
