OpenClaw April 2026: 6 Model Providers You Can Now Swap at Runtime Without Rebuilding
OpenClaw's new provider manifest lets you swap GPT-5.5, Claude, Gemini, DeepSeek, Ollama, or Gemma 4 at runtime — no workflow rebuild needed.
OpenClaw Now Supports 6 Model Providers You Can Swap at Runtime — Here’s What That Actually Changes
In April 2026, OpenClaw shipped a provider manifest that lets you swap the model brain inside a running workflow without rebuilding anything. Six providers are supported out of the box: GPT-5.5 via Codex, the Claude API, Gemini, DeepSeek, Open Router, Ollama, LM Studio, and Gemma 4. That’s more than a dropdown. It’s a structural change in how you think about agent architecture.
If you’ve been building on OpenClaw for any length of time, you know the old problem. You pick a model, you build around it, and then the provider changes a policy or a pricing tier and your workflow breaks. The provider manifest is OpenClaw’s answer to that: the action layer stays stable while the reasoning engine changes underneath it.
Here’s what each provider actually brings to the table, and why the routing decisions matter more than the model rankings.
GPT-5.5 via Codex: The Subsidized Option That Wasn’t Supposed to Exist
OpenAI made a move in late April that most people underreported. The Codex OOTH route — meaning you authenticate through your existing ChatGPT subscription rather than a separate API key — is now documented directly in OpenClaw’s provider docs alongside direct API usage. Sam Altman confirmed on May 1st that OpenClaw is “flat available under ChatGPT paid plans.”
That’s a meaningful subsidy. If you’re already paying for a ChatGPT Plus or Pro subscription, you can route OpenClaw’s hardest tasks through GPT-5.5 without a separate API bill. For builders who’ve been running Claude as their default brain, this changes the cost math on complex repo work, multi-step implementation tasks, and anything that burns a lot of tokens in a loop.
The timing is hard to ignore. Peter Steinberger, the creator of OpenClaw, now works at OpenAI. The company that employs the framework’s creator just made that framework free to use on its infrastructure. Whether that’s coordination or coincidence, the practical effect is the same: GPT-5.5 via Codex is currently the cheapest path to frontier-model performance inside an OpenClaw workflow.
Use it for: hard implementation work, complex PR reviews, anything where you need deep reasoning and you’re already inside the ChatGPT ecosystem.
Claude API: Still the High-Judgment Option, Now Metered
Anthropic’s April policy change was blunt. Using OAuth tokens from Claude Pro or Max subscriptions in third-party tools — including the agent SDK — is no longer permitted. The developer community was not happy about it, and the reaction was loud enough that it dominated the conversation for most of the month.
The policy makes sense from Anthropic’s perspective, even if the timing was rough. Agents aren’t normal chat users. They run longer, retry more, carry more context, and generate intermediate work that a human never sees. A flat-rate consumer subscription was never designed to absorb that load. Nate Jones, who covers OpenClaw closely on his Substack, framed it clearly: Anthropic is effectively saying Claude is powerful enough to be an agent brain, but they want it paid for like infrastructure.
What this means in practice: Claude via the direct API is still in the provider manifest, and it’s still the right call for tasks where judgment, writing quality, or architectural reasoning is worth the metered cost. It’s just no longer the cheap always-on substrate for background loops. That’s a different design assumption, and it’s worth being explicit about it in your routing logic.
For context on how Claude and GPT-5.5 stack up on specific task types, the GPT-5.4 vs Claude Opus 4.6 comparison covers the tradeoffs in detail — the pattern holds at the newer model versions too.
Use it for: high-stakes writing, architecture decisions, anything where you’d pay a premium for a second opinion from a careful thinker.
Gemini: Google’s Play for the Middle Layer
Gemini is in the manifest as a hosted option that sits between frontier-model pricing and local model constraints. Google hasn’t made a single dramatic move on OpenClaw integration the way OpenAI did with the Codex OOTH route, but Gemini’s presence in the provider list reflects the broader reality: if you’re routing work across multiple models, you want Google in the mix for tasks that benefit from its multimodal capabilities and long context handling.
The more interesting Google story in April is Gemma 4, which we’ll get to. But for hosted Gemini, the practical case is bulk summarization, document processing, and tasks where you need a capable model without paying GPT-5.5 prices for every call.
DeepSeek and Open Router: The Cost-Optimization Layer
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
DeepSeek’s inclusion in the manifest is about one thing: cost. For high-volume tasks where you need solid reasoning but not frontier-model performance, DeepSeek offers a meaningful price-per-token advantage. Open Router sits above it as an aggregation layer — if you want to route to DeepSeek, Mistral, or a dozen other models through a single API endpoint, Open Router handles that without requiring separate credentials for each provider.
The combination matters for durable workflow design. If your OpenClaw loop runs a first-pass classification on every incoming GitHub issue before deciding whether to escalate to GPT-5.5, you don’t want to pay frontier prices for the classification step. DeepSeek via Open Router is the kind of routing decision that makes a workflow economically viable at scale.
Platforms like MindStudio handle this kind of multi-model orchestration visually — 200+ models, 1,000+ integrations, and a builder for chaining agents without writing the routing logic from scratch. But if you’re already in the OpenClaw ecosystem, the provider manifest gives you the same flexibility at the framework level.
Ollama and LM Studio: The Local Branch
Ollama and LM Studio are the two local inference options in the manifest, and their presence signals something important about where OpenClaw is headed. Not every agent step deserves frontier-model pricing. Not every workflow should require an internet connection. And not every organization is comfortable routing sensitive data through a third-party API.
Ollama is the simpler path: install it, pull a model, point OpenClaw at the local endpoint. LM Studio adds a GUI and makes it easier to manage multiple local models. If you want a step-by-step on getting a local model running and connected to an agent workflow, the guide to running Claude Code for free using Ollama and Open Router covers the setup in detail.
The practical use case is background classification. If your workflow needs to triage incoming items, detect duplicates, or do a first-pass categorization before routing to a more capable model, a local Ollama instance handles that without burning API tokens. The latency is higher than a hosted API, but for non-time-sensitive background tasks, it doesn’t matter.
Gemma 4: The One That Changes the Local Calculus
Google released Gemma 4 under Apache 2.0 in April, and the positioning was unusually direct. The official developer documentation describes it as built for advanced reasoning, agentic workflows, and on-device use — multi-step planning, autonomous action, offline code generation, and multimodal processing on device.
That’s not a research model. That’s a model Google is explicitly positioning for the kind of work OpenClaw does.
The Apache 2.0 license matters here. You can run Gemma 4 locally, modify it, and deploy it in commercial workflows without the licensing friction that comes with some other open-weight models. For builders who want a credible local option that can handle more than simple classification, Gemma 4 is the most capable open-weight model currently in the OpenClaw provider manifest.
The comparison of Gemma 4 and Qwen 3.5 for local AI workflows gets into the benchmark details if you want to evaluate it against alternatives. The short version: Gemma 4 is the right call if you’re already in the Google ecosystem or if you need multimodal capability at the edge.
Use it for: local classification, on-device processing, any step where you want open-weight performance without API dependency.
How the Provider Manifest Actually Works in a Real Workflow
Remy is new. The platform isn't.
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
The manifest isn’t just a list of options. It’s the mechanism that lets you build one workflow loop and route different models through it based on the step. OpenClaw’s task flow — the orchestration layer above background tasks that manages durable multi-step flows with their own state and revision tracking — is what makes this routing meaningful.
Without durable task state, swapping models mid-workflow is just a configuration change. With it, you can build a loop where a local Gemma 4 instance handles initial triage, GPT-5.5 via Codex handles the hard implementation work, and Claude API handles a final architecture review — and the workflow knows what happened at each step, what failed, and what the next model needs to know.
The incident response pattern illustrates this cleanly. When an incident starts, your OpenClaw workflow needs to pull from logs, dashboards, Slack, GitHub, runbooks, and deployment history simultaneously. A fast cheap model handles log parsing. A deep inference model handles root cause analysis. A high-judgment model drafts the postmortem. The workflow doesn’t care which brain did which step — it cares that the right output came back to the right channel at the right time.
The same pattern applies to email triage: segregate sensitive emails with a high-judgment model, draft replies with a capable mid-tier model, run a QA pass with a cheaper model, handle attachments securely. Multiple models, one durable loop.
For builders thinking about how to structure these multi-step Claude Code workflow patterns, the underlying architecture applies directly to OpenClaw’s task flow model.
The Memory Problem the Manifest Creates
Here’s the thing the provider manifest makes obvious once you start using it: if the brain is swappable, memory can’t live inside any one brain.
This is where the OpenBrain project becomes relevant. When you’re routing work across six different model providers, you need a memory layer that exists independently of all of them. OpenBrain’s memory provenance labels — observed from source, inferred by model, confirmed by user, imported from transcript — give you a way to track where a piece of memory came from regardless of which model wrote it. The code review memory recipe stores reusable lessons from PRs. The task flow worklog records what a long-running agent attempted, what changed, what blocked it, and what the next agent should know.
Without provenance labels, memory from a GPT-5.5 session and memory from a Gemma 4 session look identical. With them, you know which claims are high-confidence and which are model inferences that need verification. That distinction matters a lot when you’re building workflows that need to survive model churn.
The OpenClaw best practices guide from 200+ hours of use covers memory architecture in the context of real workflows — the section on model routing is particularly relevant now that the provider manifest makes multi-model routing a first-class feature.
The Routing Decision Is Now the Architectural Decision
The old question was: which model is best? The April provider manifest makes that question obsolete. The better question is: which model should handle this step?
Day one: idea. Day one: app.
Not a sprint plan. Not a quarterly OKR. A finished product by end of day.
Use a local Gemma 4 or Ollama model for cheap background classification, duplicate detection, and low-risk triage. Use GPT-5.5 via Codex for hard implementation and complex repo work — especially if you’re already on a paid ChatGPT plan. Use Claude API when judgment, writing quality, or architectural reasoning is worth the metered cost. Use DeepSeek via Open Router for bulk summarization and formatting tasks where you need solid output at low cost.
This is the design principle that makes OpenClaw’s April releases add up to something larger than a feature list. The task flow gives work a durable loop. The provider manifest makes the reasoning engine swappable. The memory layer — if you build it right — gives the workflow continuity across all of it.
If you’re building a spec-driven application on top of this kind of agent infrastructure, the same principle applies at the code layer. Tools like Remy treat the spec as the source of truth and generate the full-stack application — TypeScript backend, database, auth, deployment — as derived output. The spec doesn’t change when you swap the underlying model; neither should your workflow.
The labs will keep fighting over which model runs inside OpenClaw. Anthropic will make policy decisions that reflect their compute constraints. OpenAI will make access decisions that reflect their distribution strategy. Google will keep releasing open-weight models with explicit agentic positioning. None of that should require you to rebuild your workflow from scratch.
That’s what the provider manifest is actually for.
