OpenClaw Local Model Hardware: What You Need (2026)

The "free AI agent" dream has a hardware price tag. Here's the honest breakdown of what runs, what struggles, and what's not worth the electricity.

Quick answer: A useful local OpenClaw setup needs 32GB RAM minimum (16GB only works for 7B chat-only experiments), and either a GPU with 24GB+ VRAM (used RTX 3090, RTX 4090, or RTX 5090) or an Apple Silicon machine with 32GB+ unified memory. Plan on roughly $30-100/month all-in once you factor hardware depreciation, electricity, and maintenance time. Tool calling works with OpenClaw's native Ollama provider as of April 2026 — if you're still on the /v1 OpenAI-compatible path, see the troubleshooting guide.

A developer in our community bought a used RTX 3090 in early 2026 specifically to run local models with OpenClaw. He spent $650 on the GPU, $80 on a new power supply, and a weekend installing everything. Ollama loaded. The model ran. But tool calls silently failed because OpenClaw's /v1 Ollama path dropped streamed tool-call responses — a bug that's since been resolved by switching to the native /api/chat provider. The hardware question survived: what do you actually need to make local OpenClaw worth the build?

This guide covers the actual hardware requirements for running local models with OpenClaw, what those local models can and can't do, and whether the total cost of ownership actually saves money compared to cloud APIs. For the setup walkthrough itself, see the OpenClaw local model setup guide.

The hardware floor: what you need at minimum

Running Ollama with OpenClaw requires more resources than most people expect. The bottleneck isn't OpenClaw itself (it runs fine on minimal hardware). It's the local model that needs serious compute.

RAM is the primary constraint. Local models load entirely into memory. A 7B parameter model needs roughly 4-8GB just for the weights. Add OpenClaw's own memory footprint (its system prompt alone runs to tens of thousands of tokens, which sits in your KV cache), the OS, and any other services, and 32GB is the practical floor for a useful experience. 16GB works only for 7B chat-only experiments — community guides converge on 32GB once you actually load OpenClaw's prompt and try agent tasks.

VRAM matters more than RAM if you have a GPU. Running models on a dedicated GPU is dramatically faster than CPU inference. An NVIDIA RTX 3060 with 12GB VRAM can run 7B models comfortably. A used RTX 3090 or RTX 4090 with 24GB VRAM can handle models up to about 30B parameters. For glm-4.7-flash (30B-A3B MoE, ~19GB at q4_K_M quantization), 24GB VRAM is enough at q4 — higher quants need a 32GB card.

Apple Silicon changes the math. M1/M2/M3/M4 Macs with unified memory handle local models surprisingly well because the GPU and CPU share the same memory pool. A Mac Mini M4 with 24GB unified memory runs 7B-14B models smoothly. A Mac Studio M2 Ultra with 64GB+ unified memory runs the larger models that give the best results.

CPU inference works but is painfully slow. If you don't have a dedicated GPU or Apple Silicon, Ollama falls back to CPU inference. A 7B model on a modern CPU generates maybe 2-5 tokens per second. For comparison, cloud APIs return responses in 1-2 seconds total. CPU inference makes the agent feel like it's thinking underwater.

For the complete breakdown of how local models interact with OpenClaw and the five most common failure modes, our troubleshooting guide covers each issue with specific fixes.

The models worth running locally (and the ones that aren't)

Not all local models perform equally with OpenClaw. The community has tested extensively, and the consensus is clear.

Models that work well for agents

glm-4.7-flash is the community favorite. 30B-A3B MoE architecture, ~19GB at q4_K_M and ~32GB at q8_0, requires Ollama 0.14.3 or newer. Strong reasoning and code generation. Pull with ollama pull glm-4.7-flash. Fits on a 24GB GPU at q4 and on Apple Silicon machines with 32GB+ unified memory.

qwen3-coder:30b performs well for code-heavy conversations. 30.5B params / 3.3B active MoE with a 256K-token native context. Note: the official model card lists ~250GB memory at full precision — for most builds you'll be running an aggressive quant, which fits comfortably in 24-32GB. Pull with ollama pull qwen3-coder:30b.

hermes3 (the official Hermes 3 in Ollama's library; hermes-2-pro was the previous generation) and mistral:7b are the lightweight tool-calling picks for 16-24GB machines. Lower reasoning ceiling than the 30B+ models above, but they run anywhere and they get the tool-call format right.

Newer models worth a look (released 2026)

The Ollama library has moved fast in early 2026. A few notable additions:

• qwen3.6:35b-a3b — Qwen 3.6 MoE designed explicitly for agentic workflows (35B total / 3B active). Pull with ollama pull qwen3.6:35b-a3b.
• qwen3.5:9b — Sweet-spot smaller Qwen for 16-24GB machines.
• gemma4:e4b and gemma4:26b — Google's Gemma 4 generation (April 2026), Apache 2.0 licensed. gemma4:e4b is a strong 16GB-machine option; the 26B MoE variant fits comfortably on 24GB GPUs.
• gpt-oss:20b — OpenAI's open-weight 21B MoE (3.6B active), MXFP4-quantized, runs on 16GB. Note the tag uses a colon (gpt-oss:20b), not a hyphen.
• llama4:scout and llama4:maverick — Meta's Llama 4 MoEs (Scout 109B / Maverick 400B, both 17B active). Maverick is workstation-or-server territory; Scout is feasible on a 24GB GPU at quantization.

One-command setup: ollama launch openclaw

Ollama 0.17 added a launch subcommand that auto-downloads, installs, and configures OpenClaw to use the local Ollama daemon (verified via Ollama's blog and the OpenClaw integration docs):

ollama launch openclaw --model glm-4.7-flash

The --model flag pre-pulls the model. Without flags, it walks you through a TUI picker. This replaces the manual provider config most older guides describe.

Models to avoid

Anything under 7B parameters. Models like phi-3-mini (3.8B) and qwen2.5:3b technically run but produce unreliable results for agent tasks. Context tracking degrades quickly. Instructions get ignored or misinterpreted. Not worth the electricity.

Unquantized large models on insufficient hardware. If your hardware forces heavy quantization (Q2 or Q3), the model quality drops dramatically. You're better off running a smaller model at higher quality than a large model at extreme quantization.

Ollama's own OpenClaw integration docs recommend setting the context window to at least 64K tokens. Many popular models default to much less. Configure this explicitly to avoid the agent running out of context mid-conversation.

For guidance on choosing the right model for your agent's specific tasks, our model comparison covers cost-per-task data across local and cloud providers.

Tool calling: what works now, and what still trips people up

For most of early 2026, the honest answer was that tool calling didn't work for local models through OpenClaw. The reason was documented in GitHub Issue #5769: OpenClaw sent requests via the OpenAI-compatible /v1 path with streaming enabled, and Ollama's /v1 streaming dropped tool-call delta chunks. Your model decided to call a tool, generated the tool call, and OpenClaw never saw it.

That's been resolved. OpenClaw's native Ollama provider now integrates directly with Ollama's /api/chat endpoint, which preserves tool calls under streaming. The official Ollama provider docs explicitly warn against using the /v1 URL because it still breaks tool calling. If your config points at http://localhost:11434/v1, drop the /v1 and update OpenClaw. Then run openclaw doctor --deep to confirm.

What that means for the hardware question:

• Buying a GPU for OpenClaw agent tasks is no longer pointless. Tool calling works, skills execute, and the hardware investment pays off in capability.
• Model capability is still the real bottleneck. Models under ~30B parameters frequently fail on multi-step agent reasoning even when tool calling works mechanically. A 7B model that successfully emits a tool call is still a 7B model.
• If you installed before April 2026 and stopped using OpenClaw because of this, it's worth reinstalling. Update, switch to the native Ollama provider, and retest.

If you're on an older OpenClaw build and can't update, the community workaround is to patch streaming off for Ollama specifically — covered in our troubleshooting guide.

The real cost of "free" local models

The appeal of local models is zero API costs. But "zero API costs" and "zero cost" are very different things.

Let's do the actual math.

Hardware cost. Apple repriced the Mac Mini lineup on May 1, 2026 (the 256GB SSD tier was dropped and DRAM cuts pushed configurations up). The Mac Mini M4 now starts at $799 with 16GB unified memory; the M4 Pro variants now start at $1,299 and top out at 48GB unified memory (the previous 64GB option was discontinued in May 2026). On the GPU side, the RTX 5090 launched at $1,999 MSRP but typically sells for $2,500-$3,200 on the street, an RTX 4090 runs $1,600-2,000, and a used RTX 3090 runs $600-800 in good condition. Budget $80-120 for a PSU upgrade if your existing supply can't handle a 4090-class card.

Electricity. A Mac Mini M4 running 24/7 consumes roughly $3-5/month. A desktop with an RTX 4090 under load uses significantly more, roughly $15-30/month depending on electricity rates and inference frequency.

Your time. Initial setup is 1-2 hours with a recent OpenClaw release (ollama pull <model>, point the native Ollama provider at http://localhost:11434, run openclaw doctor). Ongoing maintenance (model updates, Ollama updates, occasional WSL2 networking gotchas) adds 1-3 hours per month.

Hardware depreciation. That $999 Mac Mini depreciates. That $1,800 GPU depreciates faster. Over two years, you're losing $25-75/month in hardware value.

Total monthly cost of local model ownership: roughly $30-100/month when you factor in hardware amortization, electricity, and time.

Meanwhile, cloud APIs in 2026 remain cheap enough that the math rarely favors local on cost alone. Providers like DeepSeek and Gemini's free tier run a moderate-usage agent for a few dollars a month with working tool calling and large context windows. For up-to-date numbers across providers, see our cloud cost comparison.

For the full comparison of which cloud providers cost what for OpenClaw, our provider guide covers five alternatives that are cheaper than most people expect.

When local hardware genuinely makes sense

I've just spent several paragraphs explaining why local models cost more and do less than cloud APIs. Let me be fair about the three scenarios where the hardware investment is justified.

Complete data sovereignty

If your data absolutely cannot leave your network, local models are the only option. Government agencies, defense contractors, healthcare organizations with strict HIPAA requirements, legal firms handling privileged communications. These environments have compliance requirements that no cloud API can satisfy.

For these use cases, the tool calling limitation is a real constraint, but conversational interaction with sensitive data is still valuable. A local agent that can discuss classified documents or answer questions about patient records without any data leaving the building is worth the hardware cost.

Air-gapped and offline environments

No internet means no API calls. Period. If you need an AI assistant in a facility without reliable connectivity (remote installations, secure facilities, maritime environments, some manufacturing floors), local models are the only path.

Hybrid heartbeat routing

This is the practical compromise that makes the most financial sense. Use a local Ollama model for heartbeats (the 48 daily status checks that consume tokens on cloud providers) and route everything else to a cloud model that has working tool calling.

Heartbeats don't require tool calling. They're simple status pings. Running them locally saves $4-15/month depending on which cloud model would otherwise handle them. Set the heartbeat model to your local Ollama instance and the primary model to a cloud provider like Claude Sonnet or DeepSeek.

For the full model routing configuration including the hybrid local/cloud approach, our routing guide covers the setup pattern.

If managing local hardware, cloud APIs, and model routing configuration feels like more infrastructure work than your agent is worth, BetterClaw handles model routing across 28+ providers with a dashboard dropdown. $19/month per agent, BYOK. Pick your models. Set your limits. Deploy in 60 seconds. No hardware to buy, no Ollama to debug.

The hardware buying guide (if you're still committed)

If your use case genuinely requires local models, here's what to buy at each budget level.

Budget tier (~$800-1,000). Mac Mini M4 — base 16GB for chat-only experimentation, 24GB upgrade for a usable agent. Runs 7B-14B models at decent speed. Quiet. Low power consumption. Handles chat interactions and hybrid heartbeat routing without issue.

Mid-range tier (~$1,300-2,000). Used RTX 3090 (24GB VRAM, $600-800 on the secondary market) in an existing desktop, or a Mac Mini M4 Pro starting at $1,299 with up to 48GB unified memory. Runs models up to 30B parameters. Better reasoning quality, faster inference. Good enough for glm-4.7-flash at q4 or qwen3-coder:30b at aggressive quantization.

Power user tier (~$2,500-5,000). Two paths now:

• RTX 5090 in a workstation. $1,999 MSRP, $2,500-$3,200 street. 32GB GDDR7 and roughly 35-50% more tokens-per-second than a 4090 on typical LLM inference. The first consumer GPU that fits 30B-class models comfortably above q4.
• Apple M5 Max (announced March 3, 2026, MacBook Pro / Mac Studio refresh). Up to 128GB unified memory, which is the sweet spot for running 70B-class models without aggressive quantization. Slower than NVIDIA per-token but the memory ceiling is unmatched for the price.

The previous-gen Mac Studio M3 Ultra is still available (256GB cap after the 512GB option was discontinued in March 2026) and remains the best pure-memory option if you can find one in stock.

What not to buy. Don't buy a cloud GPU instance (Lambda Labs, Vast.ai) for running Ollama with OpenClaw. The per-hour cost of a GPU instance (typically $0.50-3.00/hour) adds up to $360-2,160/month. That's 10-100x more expensive than cloud API costs. GPU instances make sense for training models. They make no sense for inference.

Where local stands today (and where it still trails cloud)

With native tool calling working, the gap between local and cloud has narrowed for tasks that don't require frontier-level reasoning. glm-4.7-flash and qwen3-coder:30b are genuinely useful for agent work on the right hardware. Skills execute. Heartbeats run cheaply. Code-heavy workflows run locally without needing to round-trip a cloud provider.

But "narrowed" isn't "closed." Cloud models like Claude Sonnet still outperform local models on complex multi-step reasoning, long-context accuracy, and prompt injection resistance. The hardware requirements for running competitive local models (24GB+ VRAM at q4, 32GB+ for higher quants, 64GB+ unified memory on Apple Silicon) put them out of reach for casual users. And cloud inference is just faster — a 30B-class model on a 4090 is several times slower per token than the same model on a hosted API.

The practical answer remains hybrid. Cloud for the tasks that need it. Local for privacy-sensitive conversations, heartbeats, and the cost savings on high-volume background tooling. OpenClaw's model routing supports the split out of the box.

The managed vs self-hosted comparison covers how these choices translate across deployment options, including what BetterClaw handles versus what you manage yourself.

If you want an agent that works with any cloud provider, supports 15+ chat platforms, and deploys without buying hardware or debugging Ollama, give BetterClaw a try. $19/month per agent, BYOK with 28+ providers. 60-second deploy. Docker-sandboxed execution. Your agent runs on infrastructure that's already optimized. You focus on what the agent does, not what it runs on.

Frequently Asked Questions

What hardware do I need to run local models with OpenClaw?

32GB RAM and a GPU with 24GB+ VRAM (used RTX 3090, RTX 4090, or RTX 5090) is the practical floor for a useful agent experience. Apple Silicon equivalent: 32GB+ unified memory. 16GB only works for 7B chat-only experiments. Configure Ollama's context window to at least 64K tokens for OpenClaw.

What GPU do I need to run a 30B model with OpenClaw?

24GB VRAM at q4_K_M quantization is the minimum — a used RTX 3090 ($600-800) or an RTX 4090 fits glm-4.7-flash or qwen3-coder:30b comfortably. For higher quants, step up to a 32GB RTX 5090. On Apple Silicon, 32GB unified memory works at q4, 48GB+ for higher quality.

Can I run OpenClaw on a Mac Mini?

Yes. The base Mac Mini M4 (now $799 with 16GB after May 2026 repricing) runs 7B-14B models adequately. The 24GB upgrade is the sweet spot for daily use. The Mac Mini M4 Pro ($1,299+, up to 48GB) runs 30B-class models at quantization. The previous-gen Mac Studio M3 Ultra goes higher if you need 70B-class local inference.

How do I set up Ollama with OpenClaw?

Easiest path: run ollama launch openclaw --model glm-4.7-flash (Ollama 0.17+). This auto-installs and configures the gateway. Manual path: install Ollama, pull your model, point OpenClaw's Ollama provider at http://localhost:11434 (no /v1), set context window to 64K+, and run openclaw doctor --deep to verify.

Is running OpenClaw locally cheaper than cloud APIs?

Usually not on cost alone. A Mac Mini M4 depreciates roughly $25/month over two years plus $3-5/month electricity. Total: $30-40/month, with comparable cloud usage often running a few dollars on cheap providers. Local wins for data sovereignty, offline use, or high-volume heartbeats — not for cost savings alone.

Can I use both local and cloud models with the same OpenClaw agent?

Yes. OpenClaw's model routing supports hybrid configurations. Route heartbeats (48 daily status checks) to a local Ollama model to save cloud tokens, and route primary tasks to a cloud provider like Claude Sonnet or DeepSeek. Now that local tool calling works, this also lets you offload many tool-using tasks to local.