Openclaw April 2026 Update Adds xAI, MiniMax

Openclaw shipped its April 2, 2026 update with a long list of changes, but the headline is simple: the project is pushing harder on provider support, plugin ownership, and safer execution defaults. This release touches everything from xAI and MiniMax to task flow orchestration and channel approvals.

There are also some hard numbers hiding in the notes. The release includes dozens of provider, channel, and runtime fixes, plus migration paths for older config layouts through openclaw doctor --fix. If you use Openclaw in a multi-channel setup, this is the kind of update that can quietly save a weekend.

Plugin ownership is getting stricter

The biggest structural theme in this release is that Openclaw is moving more settings out of legacy core paths and into plugin-owned config. That matters because it reduces ambiguity about which module owns which behavior, and it makes future upgrades less fragile.

Two changes show the pattern clearly. The xAI web search settings move from tools.web.x_search.* to plugins.entries.xai.config.xSearch.*, while Firecrawl web fetch moves from tools.web.fetch.firecrawl.* to plugins.entries.firecrawl.config.webFetch.*. In both cases, Openclaw also points users to openclaw doctor --fix for migration.

• xAI settings now live under plugin-owned config paths
• Firecrawl web fetch also moved into plugin-owned config
• Legacy config can be migrated with openclaw doctor --fix
• Web fetch fallback now routes through a fetch-provider boundary

That last point is more important than it sounds. A provider boundary means Openclaw can treat web fetch as a capability with clearer rules, instead of baking Firecrawl-specific logic into the core. For anyone running multiple providers, that is a cleaner model and easier to reason about.

Openclaw also improved provider routing elsewhere. The release centralizes request auth, proxy, TLS, and header shaping across HTTP, stream, and websocket paths. It also hardens endpoint classification for OpenAI-compatible, Anthropic, and Copilot-style routing so spoofed or malformed hosts fail closed instead of inheriting the wrong defaults.

Task flows now look more like a real runtime

Openclaw’s task flow work is probably the most interesting engineering change in the release. The notes say the project restores the core Task Flow substrate with managed-versus-mirrored sync modes, durable state and revision tracking, plus inspection and recovery primitives.

That is a strong signal that Openclaw wants task orchestration to be a first-class runtime concern, not just a plugin feature. It also adds managed child task spawning and sticky cancel intent, which means external orchestrators can stop scheduling immediately while active child tasks finish cleanly.

“We’re building for the long haul, and the path there is through a strong product and strong execution.” — Sam Altman, OpenAI CEO, in a 2024 memo to staff

The quote above is not about Openclaw specifically, but it fits the direction here: runtime control matters when an AI system grows beyond one-off prompts. Openclaw is clearly trying to make background orchestration, approvals, and recovery behave like parts of an actual operating system for agent work.

There is also a new bound api.runtime.taskFlow seam for plugins and trusted authoring layers. That lets code create and drive managed task flows from host-resolved context without passing owner identifiers on every call. It is a small API shift with a big effect on ergonomics.

• Managed and mirrored sync modes are now explicit
• Task flow state and revision history are durable
• Child task cancellation is sticky instead of ambiguous
• Plugins can use a bound runtime seam for task flow control

Openclaw also added a before_agent_reply hook. That lets plugins short-circuit the model with synthetic replies after inline actions, which is useful when the answer is already known and there is no reason to pay for another model turn.

Exec approvals and onboarding get safer

This release makes a clear bet: default behavior should be safer, and setup should be less painful. On the exec side, gateway and node host exec now default to YOLO mode by requesting security=full with ask=off, while approval-file fallbacks and doctor reporting are aligned with that no-prompt default.

Openclaw also normalizes malformed approval policy values in ~/.openclaw/exec-approvals.json, stripping invalid security, ask, and askFallback entries so runtime policy resolution falls back to documented defaults. That is boring infrastructure work, but it prevents one bad config file from poisoning the whole approval path.

Onboarding gets attention too. Matrix channel setup is restored in openclaw channels add and openclaw configure --section channels, and the release keeps custom plugin wizards on the shared setupWizard seam. For people who have been burned by setup regressions, that is the kind of fix that gets noticed fast.

• Exec defaults now favor no-prompt behavior for host and gateway flows
• Malformed approval JSON is normalized during runtime startup
• Matrix guided setup is back in channel configuration flows
• Custom plugin wizards still use the shared setup path

There is also a channel-side improvement that matters in daily use: DM-first native chat approvals can auto-enable when supported channels infer approvers from existing owner config. That reduces friction while still keeping fanout explicit and approval behavior visible.

Comparing this release with the older model

If you compare this update with older Openclaw behavior, the direction is obvious. The project is moving from loosely coupled feature plumbing toward explicit ownership, stricter transport policy, and better runtime boundaries. That is a lot of work, but it pays off when the system needs to support more providers and more channels without turning into a tangle.

Here are a few concrete comparisons from the release notes:

• Before: xAI and Firecrawl settings lived under core paths. Now: they live under plugin-owned paths with migration support.
• Before: task flow behavior was less explicit. Now: managed state, revisions, and recovery are built into the substrate.
• Before: exec policy defaults were easier to misread. Now: malformed values are normalized and reporting matches the real approvals file path.
• Before: provider routing could inherit the wrong defaults more easily. Now: native-vs-proxy classification is centralized across OpenAI-compatible, Anthropic, Copilot, and media paths.

There is a practical upside for users too. Openclaw now centralizes request handling for OpenAI-compatible audio, Deepgram audio, Gemini media, Moonshot video, and image generation paths, including MiniMax and fal. That means fewer one-off code paths and fewer surprises when you change a base URL or auth setting.

The release also tightens security around transport and local access. It blocks insecure TLS or runtime transport overrides, keeps proxy-hop TLS separate from target mTLS settings, and routes Mattermost probes through the SSRF guard. For a tool that can touch many services and endpoints, that is exactly the kind of hardening you want to see.

What this means for teams using Openclaw

If you already run Openclaw in production-like workflows, this release is less about shiny features and more about control. The new approval hooks, provider boundaries, and task flow state model make the system easier to operate when multiple channels and plugins are in play.

The most useful takeaway is probably this: if you depend on xAI, MiniMax, Firecrawl, Matrix, Slack, or WhatsApp integrations, you should plan a config review before upgrading. The migration path exists, but the release is clearly moving ownership into plugin and provider modules, and old assumptions will age badly.

My read is that Openclaw is preparing for a busier 2026 by cleaning up the contract between runtime, plugins, and providers. If the team keeps this pace, the next question is not whether it can add more integrations, but whether operators can keep those integrations understandable. That is the metric to watch on the next release.

For now, the actionable move is simple: run openclaw doctor --fix, check your approval files, and verify any provider-specific config paths before pushing the update into shared environments.