OpenClaw Production Gotchas: 10 Silent Failures and Real Fixes (2026)

OpenClaw production gotchas from real fleet ops, including what "assistant turn failed before producing content" means. 10 silent failures the docs miss.

OpenClaw Production Gotchas: 10 Silent Failures and Real Fixes (2026)

OpenClaw’s worst production failures are silent. They don’t throw an error, they just stop working: config changes that don’t propagate (OpenClaw keeps model config in four separate stores), heartbeat death from a missing file, gateway race conditions that revert your edits, and post-upgrade token loops. This guide gives the verified fix for 8 of them, from real fleet operations.

TL;DR: We’ve been running OpenClaw in production across multiple agents. The documentation covers setup. It does not cover what breaks after you deploy. Here are 10 silent failures we discovered: config drift across separate model stores, heartbeats that die without logging errors, a gateway race condition that overwrites your edits, agents rewriting their own configs, upgrade-induced config drift that breaks three systems at once, hidden cost traps, hot reload behavior that silently fails, gateway token mismatch after upgrades or container recreation, cron jobs that quietly stop firing with no error anywhere, and a config key that accepts your value and ignores it. Each gotcha includes the symptom, root cause, and fix.


Contents


OpenClaw production is where the real learning starts. The setup guides will get you running. They won’t tell you what breaks at 2 AM on a Tuesday when your cron jobs silently switch back to a paid model you thought you disabled three days ago.

We’ve been running OpenClaw in production, through several platform upgrades: the kind of deployment that keeps revealing new failure modes. This post is the guide we wish existed when we deployed. Every gotcha here is a silent failure: no error message and no log entry.

If you’re brand new to OpenClaw, our what OpenClaw is primer explains what it does before you dig into failure modes. If you haven’t set up OpenClaw yet, start with our OpenClaw setup guide. This post assumes you’re already deployed and wondering why things aren’t working the way the docs say they should.


Looking for a Specific Error Message?

This page is about silent failures - the ones that never print anything. If you landed here after searching an exact error string, that string has its own guide:

Everything below produces no error message at all, which is what makes it expensive.

The Four Model Stores: Why Config Changes Don’t Propagate

Confused lobster surrounded by four filing cabinets with different settings in each drawer

What you see: You change the model in the main config file. Interactive sessions use the new model. But cron jobs keep using the old one. API costs spike from an unintended fallback.

Why it happens: OpenClaw stores model configuration in four separate places:

  1. Main config file (defaults and per-agent model settings)
  2. Session state files (cron sessions bake the model at creation time)
  3. Cron job payloads (the scheduler stores its own model reference)
  4. Model allowlist (enforced by crons, bypassed by interactive sessions)

Changing the main config does not propagate to the other three. This is OpenClaw config drift in action. Your crons fire with stale models, time out on a model that no longer exists or isn’t loaded, fall back to a paid API provider, and burn credits you thought you eliminated.

The allowlist trap: The model allowlist is enforced by cron jobs but NOT by interactive sessions. You’ll switch to a new model, test it interactively, see it work perfectly, and walk away confident. Then your crons fail with “model not allowed” because you never added the new model to the allowlist. No error in the dashboard. No notification. Just silent failures and an API bill.

The fix: Update all four stores together, then restart the gateway. Order matters: the gateway writes in-memory state to disk on shutdown, so a restart before the update overwrites your changes.

A model switch is not a single config change. It is a coordinated update across several files, in a specific order.

Lesson: If OpenClaw is using the wrong model on cron jobs, don’t just check the main config. Check session state files, cron payloads, and the allowlist. The discrepancy is almost always between stores.


Silent Heartbeat Failures: The Missing File Nobody Documents

What you see: Your agent’s heartbeat stops firing. Logs show nothing. Config looks correct. The doctor command reports no issues.

Why it happens: A required file (models.json) is missing from the agent directory. OpenClaw silently skips heartbeat execution rather than logging an error. Everything looks correct. Nothing tells you it’s broken.

Config changes, restarts and new intervals do nothing here, because the config was never the problem. The missing file is.

Every agent directory needs these files for heartbeat execution:

  1. SOUL.md (agent identity)
  2. models.json (provider configuration)
  3. auth-profiles.json (authentication store)

Missing any of these causes silent failure. Not “error and retry.” Not “warning in logs.” Silent. The heartbeat just never runs. If your OpenClaw heartbeat is not working, check these files first.

Broader lesson: OpenClaw has several “required but undocumented” files. When something silently fails, compare a working agent’s directory to the broken one. The difference is usually a missing file, not a config mistake.


Gateway Race Condition: Why Your Config Edits Disappear

What you see: You edit a config file while the gateway is running. Your changes work briefly, then disappear. Or they never take effect at all.

Why it happens: The gateway loads session state into memory at startup and periodically syncs it back to disk. When you edit files on disk, the gateway’s in-memory state overwrites your changes within seconds.

This is not a bug. It’s architecture. The gateway owns those files. You are a guest editing them.

Why this matters for model switching: If you change model config and don’t restart the gateway, it overwrites your changes from its in-memory state. Then you assume the change “didn’t work” and start debugging the wrong thing. You’re not looking at a broken config. You’re looking at a config that keeps getting reverted by the process that owns it.

The fix: Stop the gateway. Patch files. Start the gateway. That’s the only reliable sequence. Never edit config files while the gateway process is running.

If you docker self-host OpenClaw, bind mounts into the container’s config directory let you patch from the host. That alone makes a self-hosted deployment worth it over cloud platforms where you’re stuck with their own config tools.


When Agents Modify Their Own Config Files

What you see: Config files contain model names that don’t exist, API endpoints that were deprecated, or references to CLI tools the agent can’t access.

Why it happens: Given enough autonomy, agents hallucinate capabilities and write them into their own config files. An agent that believes it has tools it does not have can write them into its config and break its own execution environment.

The fix: two-layer defense.

Layer 1: Prompt rules. Add explicit rules to your agent’s instructions prohibiting config file modification. Put them in your agent’s instructions.

Layer 2: File permissions. Make the workspace files your agent should never rewrite read-only, so a write attempt fails instead of succeeding.

The permissions trap: You can’t lock everything. The gateway actively writes to auth-profiles.json (credential sync on every session init), models.json (provider config resolution) and auth.json (plugin SDK auth storage), so those must stay writable.

Locking everything is the common version of this mistake, and it fails immediately: agents break on session init with EACCES errors the moment the gateway tries to write. The test is simple. Before you lock a file, ask whether the gateway writes to it during a session, not just at startup.

The rule: Lock what agents write. Don’t lock what the gateway writes.


Upgrade-Induced Config Drift: What Breaks When You Update

Lobster pressing the update button while the office falls apart around them

You update OpenClaw to a new version. The gateway starts. No errors. Everything looks fine. Then, hours or days later, you notice behavior degrading. Per-agent settings you configured weeks ago have no effect. Heartbeat intervals reset to defaults. Or worse: “gateway token mismatch” and agents can’t authenticate at all.

Why it happens: OpenClaw’s config schema changes between versions. Keys that were valid become silently invalid. New required fields appear without migration warnings. Gateway tokens may need regeneration after major version jumps.

The Clawdbot-to-OpenClaw rebrand and the version updates after it each introduced config drift that did not surface immediately.

The silent part: The gateway starts without errors. openclaw doctor --fix is the only tool that reveals stale keys. Your per-agent thinking level override? Silently dropped after the upgrade. Custom compaction settings? Gone. Browser profile defaults? Reset. You don’t notice until an agent starts behaving differently and you can’t figure out why.

The compounding effect: This is what makes OpenClaw upgrade breaking changes dangerous. Upgrade drift activates every other gotcha in this post. Stale model stores (Section 1) get worse when the allowlist schema changes. Heartbeat files (Section 2) may need new required fields. Hot reload behavior (Section 7) changes between versions. One upgrade can silently break three systems at once.

The fix: Keep a rollback path before you upgrade, and run openclaw doctor --fix straight afterwards: it finds the keys the new version silently ignores. Not everything is auto-migrated, and an interactive session working is no proof that crons do. Token format also changes between major versions, which GitHub Discussion #4608 confirms was a widespread pain point after the Clawdbot-to-OpenClaw migration.

Lesson: Treat every OpenClaw update as a potential config migration event. The update itself takes 30 seconds. The silent config drift it introduces can take days to fully surface.


Cost Optimization That Actually Works

Lobster in hard hat presenting a server rack with tiered shelves from cheap to expensive

Here’s the silent cost failure: you switch to local models to save money. But stale cron configs keep firing paid API calls (Section 1). Heartbeats routed to local models fail silently when the model is unloaded (Section 2). Agents appear dead with no error. The “optimization” costs you more than what you saved.

OpenClaw cost optimization that works starts with one question: which tasks actually need expensive models? Routine procedure rarely does, and reasoning-heavy work usually does.

The heartbeat routing rule: Don’t route heartbeats to local models. If your local inference server is down or the model isn’t loaded, heartbeats fail silently and agents appear dead. Use a cheap API model for heartbeats. It’s always available. The reliability is worth the fraction of a cent.

Context window right-sizing: Context allocated above the platform’s actual limit costs memory and is never used. Check that limit before you size the window.

Start by matching models to tasks, not with a wholesale switch. If you’re setting up Ollama for the local tier, our OpenClaw + Ollama local LLM guide covers the production config, which models actually work for agent tasks, and the context window trap that silently breaks everything.


Hot Reload vs. Restart: Know the Difference

OpenClaw hot reloads most config changes without a gateway restart. But “most” is doing heavy lifting in that sentence.

What hot reloads (no restart needed):

  • Browser profiles (CDP URLs, profile names)
  • Heartbeat intervals
  • Model parameters
  • Agent bindings (Telegram, Discord channels)

What requires a restart:

  • Gateway binding/port changes
  • Major structural changes to agent configuration

The silent failure trap: Invalid config keys prevent hot reload from executing. You add a setting to a per-agent config block, save the file, check the logs. No reload happened. No error either.

The problem: some settings only work at the global agents.defaults level, not per-agent. Per-agent overrides for browser profile defaults and compaction settings are not accepted. The gateway doesn’t warn you. It just skips the reload.

The diagnostic tool: Run openclaw doctor --fix. It finds and removes invalid config keys. If you’ve been troubleshooting a setting that “isn’t working,” this command will tell you whether the key was valid in the first place. For a full walkthrough of every flag and what each repair does, see the complete openclaw doctor guide. If you are wiring an agent to attempt these repairs on its own, the trigger, scope and verification steps are covered in how to set up automatic bug fixing with OpenClaw.

The schema gotcha: The config schema is stricter than it appears. Keys that look reasonable (browser or compaction at the agent level) are invalid there. The docs don’t always specify which level each setting supports. When in doubt: set it in agents.defaults, test, then try moving it per-agent.


How Do You Configure OpenClaw Compaction in agents.defaults?

OpenClaw compaction is configured only under agents.defaults.compaction, because agent entries have no compaction key in the 2026.10 schema.

Compaction is how OpenClaw keeps a long session inside the model’s context window: it summarizes older turns into one entry and keeps recent messages word for word. The full history stays on disk; only what the model sees next turn changes. It is on by default, so most setups never touch it until a long session starts losing context.

A compaction block inside an agent entry is a key the schema does not know, which is the per-agent trap from Hot Reload vs. Restart. Move it to agents.defaults.

What Turning It Off Does Not Stop

enabled: false stops the proactive compaction that runs as a session nears its limit. It does not stop overflow recovery: when a provider returns a context-overflow error, OpenClaw still compacts and retries. Manual /compact in a chat also keeps working.

To check whether compaction is running, look for embedded run auto-compaction start and complete in the gateway log, or run /status, which shows a compaction count.

Custom Summary Instructions Moved Into Code

Older configs carried free-text compaction instructions, but those fields are retired and openclaw doctor strips them. Custom summaries now come from a compaction provider plugin that implements summarize(), set with compaction.provider. Setting a provider forces safeguard mode, and OpenClaw falls back to its built-in summarizer if the provider fails.


Gateway Token Mismatch: The Post-Upgrade Authentication Wall

What you see: Agents stop connecting after an upgrade or container rebuild. Logs show unauthorized: gateway token mismatch. Interactive sessions won’t start. Cron jobs fail. The gateway is running fine, it just refuses every connection.

Why it happens: The gateway generates an authentication token on first run and stores it internally. Your agents reference that same token in their auth.json files. When those tokens fall out of sync, the gateway rejects every request.

Three things break the sync:

  1. Version upgrades. The token format changed between the Clawdbot-to-Moltbot rename, and again during the Moltbot-to-OpenClaw rebrand. Old tokens are permanently invalid against the new gateway. This isn’t a “restart and it works” situation. The old token will never validate.

  2. Container recreation. If you docker compose down && docker compose up instead of docker compose restart, Docker can create a fresh container with a fresh gateway token. Your agents still have the old token baked into their auth files. Everything was working ten minutes ago. Now nothing connects.

  3. Multiple gateway instances. If you accidentally start two gateway processes against the same config directory (easy to do during debugging), they generate conflicting tokens. One wins. Agents authenticated against the loser start failing with “gateway token mismatch” and you can’t figure out which instance they were talking to.

The debugging trap: The gateway starts cleanly and the status page shows green, so the failure only shows up later, in session logs nobody is watching. There is no dashboard alert for auth failures. “Gateway token mismatch” is not a model problem, it is an auth problem, and the two need different debugging paths.

The fix: Clear the stale token while the gateway is fully stopped, so it issues a fresh one on startup and each agent picks it up on reconnect. Check connectivity right after any upgrade instead of waiting for overnight cron failures. Prefer a restart over recreating the container, because a restart keeps the token state (see Upgrade-Induced Config Drift).

Lesson: “Gateway token mismatch” is one of the few OpenClaw errors that actually tells you what’s wrong. But it looks like a config error, so your instinct is to start digging through config files when you should be regenerating tokens. If you see this error, go to the token first.


Cron Jobs That Silently Stop Working

You set up a cron job. It runs fine for days. Then it stops. No error in the dashboard. No alert. The cron just quietly ceases to fire. This is one of the most common “openclaw cron not working” complaints, and it has multiple root causes that compound on each other.

The auto-update pattern: A lot of people run auto-update-openclaw as a cron job. It’s a reasonable idea: keep your deployment current without manual intervention. The problem is that the update itself can break the cron that triggered it. The cron payload was baked with the old config schema. After the update, the payload references keys or model names that the new version doesn’t recognize. The cron fires, fails silently, and the auto-update you set up to reduce maintenance becomes the thing that breaks.

The usual causes: a gateway that crashed without anyone noticing, a model no longer in the allowlist (crons enforce it, interactive sessions do not; see Model Not Allowed), a local model that is not loaded, or a sessions directory the cron cannot write to.

The non-obvious one is a stale cron payload. Cron jobs bake their entire configuration at creation time. Your main config, model allowlist, and provider settings can all be current, but the cron payload still references the old model, old schema keys, or old provider endpoints. The Four Model Stores section explains why config changes don’t propagate to cron payloads.

The fix for stale cron payloads: You can’t patch a cron payload in place. Delete the cron job and recreate it. The new job bakes the current config. This is why config changes followed by a gateway restart aren’t enough: the restart refreshes the gateway’s in-memory state, but cron payloads are stored independently.

Prevention: After any config change that touches models, providers, or the allowlist, audit your active cron jobs. If any were created before the change, recreate them. Treat cron job recreation as part of your config change workflow, not an afterthought.

For the related error message when a cron explicitly fails with a model error, see our errors explained guide. For the broader pattern of config stores falling out of sync, see The Four Model Stores above.


Authentication and Pairing: What Breaks Between Versions

The Gateway Token Mismatch section covers one specific auth failure: the gateway token falling out of sync after upgrades. This section covers the broader authentication lifecycle. OpenClaw has three distinct credential types, and knowing which one broke saves hours of debugging.

The Three Token Types

Device tokens are generated when you pair a device (phone, tablet, secondary machine) with the gateway. They identify which physical device is connecting and what scopes it has. Device tokens live in the device’s local config.

Gateway tokens are generated by the gateway on first startup. Agents use them to authenticate API calls. They live in each agent’s auth.json. This is what breaks during the token mismatch scenario.

Auth profiles are provider credentials (API keys, OAuth tokens) stored in auth-profiles.json. They authenticate the gateway against external model providers like Anthropic, OpenAI, or local Ollama instances.

What Triggers “Pairing Required”

The “openclaw 2026.2.19 pairing required fix” and similar queries appear because version upgrades can invalidate device pairings. When the gateway detects an unrecognized or expired device token, it drops into pairing mode and refuses normal operations.

Common triggers:

  • Major version upgrades. The device token format or validation logic changed. Old tokens fail silently or are explicitly rejected.
  • Container recreation. docker compose down && up creates a fresh gateway instance that doesn’t recognize existing device pairings.
  • Config directory changes. If you moved ~/.openclaw/ to a new path or changed volume mounts, the gateway can’t find its pairing records.
  • The Clawdbot-to-OpenClaw rebrand. This changed the entire auth scheme. Every device token from the old platform is permanently dead.

How to Re-Pair

A dead pairing is cleared on the device side, not in the gateway config. The gateway then enters pairing mode, and completing the pairing flow issues fresh device tokens with the scopes you select.

Token Rotation

People search for “openclaw device token mismatch rotate reissue” because they want to rotate tokens without going through the full re-pair flow. Currently, OpenClaw doesn’t support in-place token rotation. Rotating a device token means removing the pairing and pairing again, which is a full re-pair, not a rotation. If you have multiple devices paired, each one needs its own re-pair cycle.

Removing Stale Auth Profiles

If your auth-profiles.json has provider credentials for services you no longer use, remove them manually. Stop the gateway first (the race condition applies here too), edit the file, restart. Stale auth profiles won’t cause errors, but they add confusion when debugging and may trigger unnecessary credential validation on startup.

For scope-related errors when tokens don’t have the right permissions, see Missing Scope: operator.read in our errors guide.


ThinkingDefault: The Config Key Nobody Explains

People search for “openclaw thinkingdefault” and “openclaw config set agents.defaults.thinkingdefault” because they find the key in community configs and want to know where it goes. In OpenClaw 2026.10, thinkingDefault is the real key, it works at the defaults level and per agent, and the per-agent value wins.

Where it goes: agents.defaults.thinkingDefault sets the thinking level for every agent, and agents.entries.<id>.thinkingDefault sets it for one. The thinking level is how much reasoning the model does before it answers. Accepted values are off, minimal, low, medium, high, xhigh, adaptive, max and ultra, but the model’s own profile decides which of them it supports.

The resolution order: OpenClaw checks an inline directive on the message first, then a saved session override, then the agent’s own thinkingDefault. After that come per-model params.thinking settings (the agent’s, then the shared one), then agents.defaults.thinkingDefault, and finally the provider’s default.

The trap is thinkingLevel. That key exists only inside agents.defaults.compaction, where it sets the thinking level for compaction summaries.

Put it directly under agents.defaults and the config no longer matches the schema. OpenClaw validates strictly, so the gateway refuses to start until the key is removed; openclaw doctor --fix can strip it.

Why a change can look like it did nothing: a saved session override beats both config defaults. If an existing chat keeps its old level after you change thinkingDefault, send /think default in that session to clear the override. Then check the model: non-reasoning models stay off whatever you set.

For the full breakdown of model and config key management, see Models, Config Keys, and ThinkingDefault in our errors guide.


“Assistant Turn Failed Before Producing Content”: The Placeholder That Hides the Error

If a chat shows [assistant turn failed before producing content] or The agent run failed before producing a reply., neither line is the error. Both are placeholders OpenClaw puts where a reply would have been.

What the first one is: when the model’s response stream fails before any text arrives, OpenClaw still records an assistant turn so the transcript stays in order. The turn’s only text is [assistant turn failed before producing content], it is marked as an error, and the provider’s actual message is stored on the turn as a separate error field. Chat views normally hide that turn, so when you do see the placeholder, you are reading the marker instead of the cause.

What the second one is: it is the gateway’s generic fallback, used only when it has nothing more specific to say. When it can classify the failure, it prints a request failed line instead, with the reason and HTTP status, naming the provider and model when it knows them. A conversation that has outgrown the model’s context gets its own message, telling you to /compact or start a fresh session with /new.

Why the agent does not simply try again: on the next turn, OpenClaw replays the failed turn to the model as [This turn failed before it completed. Do not redo its work without confirming with the user first.]. That is deliberate. A turn can fail after some tool calls have already run, and repeating them blind could send a message or apply a change twice.

The fix: look at the gateway log for the same timestamp. The real error is there (a provider rejection, a timeout, a rate limit), and it is the thing to fix. Retrying the prompt only helps if that underlying cause was temporary.


Channel Connected but No Response: Run channels status --probe First

The most common silent failure on a chat channel is a bot that shows as online and never answers. Nothing errors, because from OpenClaw’s side nothing went wrong: a rule said not to answer, or the message never reached the agent at all, and the gateway did exactly what it was configured to do.

Start with the probe rather than the logs:

openclaw channels status --probe

Plain channels status reports what the gateway knows about each channel. --probe is the live check: it runs a probe against each account, plus an audit where the channel supports one, so the output shows works, probe failed, audit ok or audit failed next to the transport state. Add --channel telegram (or discord, slack and so on) to check one channel.

If the probe is healthy and the bot is still silent, the cause is usually access policy rather than connectivity:

  • Direct messages go nowhere: the sender is waiting on pairing. openclaw pairing list <channel> shows pending requests, and openclaw pairing approve <channel> <code> lets the sender in.
  • Groups stay silent: with requireMention on, the agent only answers when mentioned. On Telegram, the bot’s privacy mode also hides group messages that do not mention it, and on Discord the bot needs the Message Content Intent to read them.
  • One Discord channel was configured and every other channel went quiet: adding a single entry to a guild’s channels map turns it into an allowlist, and every channel not listed is denied. Add a "*" entry to keep the rest reachable.
  • A channel vanished after an update: openclaw status --all shows plugin load failed when the channel is configured but its plugin did not register. Run openclaw doctor --fix, then openclaw gateway restart.

Key Takeaways: OpenClaw Production Gotchas

  • Config drift is the biggest silent failure. OpenClaw stores models in four places. Change one, the other three stay stale. Update all four together.
  • Missing files cause silent heartbeat death. No errors, no logs. Check models.json exists in every agent directory.
  • Never edit config while the gateway is running. It overwrites from memory. Stop, patch, start.
  • Lock what agents write, not what the gateway writes. Leave models.json and auth-profiles.json writable.
  • Treat every update as a config migration. Keep a rollback path, run doctor --fix after. One upgrade can silently break three systems.
  • Don’t route heartbeats to local models. Use cheap API for reliability. Silent heartbeat failure is worse than a fraction of a cent.
  • Run openclaw doctor --fix when things silently fail. Invalid config keys are more common than you think.
  • “Gateway token mismatch” means token regeneration, not config debugging. After upgrades or container rebuilds, clear stale tokens in agent auth.json and let the gateway regenerate. Don’t waste time checking model configs.
  • Cron jobs bake config at creation time. After any config change, recreate affected cron jobs. Restarting the gateway alone doesn’t update cron payloads.
  • Three credential types, three failure modes. Device tokens, gateway tokens, and auth profiles break independently. Know which one failed before debugging.
  • thinkingDefault is the key; thinkingLevel belongs only in compaction. Set agents.defaults.thinkingDefault or a per-agent thinkingDefault. A top-level thinkingLevel stops the gateway starting.
  • [assistant turn failed before producing content] is a placeholder, not the error. The provider’s real message is in the gateway log for that moment.
  • A connected channel that never answers is usually policy, not connectivity. Run openclaw channels status --probe, then check pairing, mention rules and channel allowlists.

Getting actual error messages instead of silent failures? See our OpenClaw error reference for every common error explained with tested fixes.

Want all 10 silent failure modes with detection scripts and fixes? The OpenClaw Fleet Kit covers every failure mode in this post plus two more, with automated detection and fix procedures.

Need help with AI agent development and deployment services? We’ve already debugged these issues so you don’t have to. For self-serve fleet scaling, the OpenClaw Fleet Kit has everything from this post and more in ready-to-deploy format.


Frequently Asked Questions

Why is my OpenClaw heartbeat not firing?

The most common cause is a missing models.json file in your agent directory. OpenClaw silently skips heartbeat execution when this file is absent, with no errors in logs. Verify your agent directory contains SOUL.md, models.json, and auth-profiles.json. Compare your broken agent's directory to a working one file-by-file.

Why do OpenClaw config changes not stick after restart?

The gateway loads session state into memory at startup and periodically writes it back to disk. If you edit config files while the gateway is running, it overwrites your changes from in-memory state within seconds. The fix: stop the gateway, make your edits, then restart. Never edit config files while the gateway process is active.

How do I fix OpenClaw model not allowed errors?

Add every model you intend to use to the model allowlist in your main config. The allowlist is enforced by cron jobs but NOT by interactive sessions. You will test your model change in an interactive session, see it work, and walk away. Then your cron jobs fail silently with 'model not allowed' because the new model was never added to the allowlist.

Why does OpenClaw ignore my config file changes?

OpenClaw stores model configuration in four separate locations: the main config file, session state files, cron job payloads, and the model allowlist. Changing the main config does not propagate to the other three. Your cron jobs will keep using the old model, time out, and fall back to a paid API provider. You need to patch all four stores, then restart the gateway.

How do I switch OpenClaw models without breaking cron jobs?

Update all four model stores atomically: the main config, the model allowlist, every active session state file, and cron job payloads. Then restart the gateway. Order matters: restart AFTER patching, because the gateway overwrites config files from in-memory state on shutdown. Test with a cron job, not an interactive session, since the allowlist is only enforced on cron execution.

What does "assistant turn failed before producing content" mean in OpenClaw?

It is a placeholder, not the error. When the model's response stream fails before any text arrives, OpenClaw records an assistant turn containing only that text and stores the provider's real error on the turn separately. "The agent run failed before producing a reply." is the gateway's generic fallback for the same situation. Check the gateway log at the same timestamp for the actual cause, such as a provider rejection, timeout or rate limit.

What breaks when you update OpenClaw?

OpenClaw's config schema changes between versions. Keys that were valid become silently invalid, per-agent overrides get dropped, and gateway tokens may need regeneration. The gateway starts without errors, so you won't notice until behavior degrades hours later. Treat every update as a config migration. Keep a rollback path and run openclaw doctor --fix afterwards to find stale keys.

Is it safe to lock OpenClaw config files read-only?

Only the files your agents write. Gateway-managed files (models.json, auth-profiles.json, auth.json) must remain writable, because the gateway writes to them on session init, credential sync and config hot-reload. Locking them causes silent EACCES errors that break agent sessions.

How do I reduce OpenClaw API costs with local models?

Match the model to the task instead of switching everything at once. Routine work can move to local models, while tasks that need reasoning stay on an API model. Keep heartbeats off local models, because local model downtime causes silent heartbeat failures, and size the context window to the platform's actual limit.

Why is OpenClaw using the wrong model on cron jobs?

Cron jobs bake the model reference at creation time into their payload. When you switch models in the main config, existing cron jobs keep using the old model. They time out, fall back to a paid API provider, and burn credits you thought you eliminated. You must update the cron job payloads directly, not just the main config file.

How do I uninstall OpenClaw completely?

Stop the Docker container, remove the container and image, then delete the ~/.openclaw directory which contains all config, agent data, and session state. If you used bind mounts, clean up the mounted directories on the host. Remove any systemd services you created for browser automation or proxy forwarding. See our OpenClaw setup guide for the full installation and removal process.

How do I fix OpenClaw gateway token mismatch?

The gateway token stored in your agent config no longer matches the one the gateway expects. This usually happens after an OpenClaw version upgrade, recreating the Docker container, or running multiple gateway instances against the same config directory. The fix is to clear the stale token while the gateway is stopped and let it generate a fresh one on startup, not to debug model config. If you upgraded from Clawdbot or Moltbot, the token format changed entirely and old tokens will never validate.

Why do I get 'unauthorized: gateway token mismatch' after updating OpenClaw?

OpenClaw's gateway token format can change between major versions. The old token in your agent config becomes permanently invalid against the new gateway. Restarting alone won't fix it because the agent keeps presenting the stale token. The stale token has to be cleared so the gateway can issue a new one. Across the Clawdbot-to-OpenClaw rebrand the entire auth scheme changed, so every old token is permanently invalid.

How do I fix OpenClaw config validation failed?

The 'config validation failed' error means your config contains keys the current version doesn't recognize. The most common one is 'agent.* was moved use agents.defaults': OpenClaw moved per-agent settings under agents.defaults between versions. Run openclaw doctor --fix to automatically migrate or remove invalid keys. If that doesn't resolve it, check the changelog for your version to find which keys were renamed or restructured.

Why are my OpenClaw cron jobs not running?

Cron jobs bake their configuration at creation time, so if you changed models or config after creating the cron, the job still uses the old settings. A restart does not refresh them; the job has to be recreated. The other usual causes are a stopped gateway, a model missing from the allowlist, or a local model that is not loaded.

How do I fix 'pairing required' after updating OpenClaw?

Version upgrades can invalidate existing device pairings, especially across major versions. The device has to be paired again, which issues fresh tokens; restarting alone does not recover the old pairing. If you upgraded from an older version where the auth scheme changed entirely (like the Clawdbot-to-OpenClaw rebrand), all old pairings are permanently dead and must be recreated from scratch.

What is thinkingdefault in OpenClaw config?

thinkingDefault sets the default thinking level, meaning how much reasoning the model does before it replies. In OpenClaw 2026.10 it is valid at agents.defaults.thinkingDefault for every agent and on a single agent's entry under agents.entries, and the per-agent value wins. Do not put thinkingLevel directly under agents.defaults: that key exists only inside compaction, and the gateway refuses to start on unknown keys.

How do I fix "config validation failed" in OpenClaw?

You'll usually see this as `config validation failed: agent.* was moved, use agents.defaults` or `agents: unrecognized key main`. OpenClaw restructured its config schema between versions, moving per-agent settings under `agents.defaults`. Run `openclaw doctor --fix` first. It auto-migrates known keys. If that doesn't resolve it, open your config file and manually move agent-level settings under the `agents.defaults` block. Check the release notes for which keys were renamed. Small consolation: this error at least tells you what's wrong, unlike most of the silent failures in this post.

How do I configure compaction in OpenClaw?

Set it under agents.defaults.compaction. Agent entries have no compaction key in OpenClaw 2026.10, so per-agent compaction settings fail validation. Auto-compaction is on by default. Setting enabled to false stops threshold compaction, but overflow recovery and /compact still work.

Why is my OpenClaw channel connected but not responding?

Run openclaw channels status --probe. If the channel probes healthy, the cause is usually access policy: a direct-message sender waiting on pairing (check openclaw pairing list <channel>), a group that only answers when the bot is mentioned, or a Discord guild whose channels map has become an allowlist. After an update, openclaw status --all can also show plugin load failed, which openclaw doctor --fix and a gateway restart clear.

FleetHelp

Stop Googling OpenClaw errors.

Your agents message ours on Telegram. Production-tested OpenClaw fixes. $99/mo.

Try FleetHelp →

About the Author

Kaxo CTO leads AI infrastructure development and autonomous agent deployment for Canadian businesses. Specializes in self-hosted AI security, multi-agent orchestration, and production automation systems. Based in Ontario, Canada.

Written by
Kaxo CTO
Last Updated: October 19, 2026
Back to Insights
FleetHelp online

Your agents break at 3am.
Ours fix them.

Agent-to-agent support for OpenClaw operators. Your bots DM ours, get production-tested answers. $99/mo.

Learn More →