How people are actually cutting OpenClaw costs by 80%

By Linas Valiukas · April 10, 2026

One guy runs 19 OpenClaw agents for $6 a month. He used to spend over $1,000. Another dropped from $519 to around $50. A student runs his setup for $2.40.

These aren't theoretical numbers. They're from YouTube videos with tens of thousands of views and Reddit posts with hundreds of upvotes. Since Anthropic cut subscriptions off from OpenClaw on April 4, the community has been obsessively sharing what actually works.

We dug through all of it. Here's what people are doing, in order from "takes five minutes" to "complete overhaul."

Tier 1: Five-minute fixes that save 30-50%

These are the low-hanging fruit. If you haven't done these, you're overpaying by at least a third.

Stop using your expensive model for heartbeats

Your agent pings the LLM every 30 minutes to check if anything needs doing. That's 48 calls a day. On Opus, each one costs about $0.85-$1.05. That's $40-50/month just to ask "anything happening?" and get back "nope."

The fix takes 30 seconds. Set your heartbeat to use the cheapest model you have access to:

// In your HEARTBEAT.md or agent config
model: "haiku"  // or "ollama/llama3.2:1b" if you run Ollama

Also add these two flags from the official docs:

isolatedSession: true   // don't send full conversation history
lightContext: true      // only load HEARTBEAT.md, skip other workspace files

One Redditor in a popular r/openclaw optimization thread put it well: "The heartbeat model swap alone is probably the single biggest cost saver most people miss. I was burning tokens on Sonnet heartbeats for weeks before I realized Haiku handles them just fine."

Bonus trick from the same thread: use DeepSeek for heartbeats. The heartbeat prompt barely changes between calls, so the cache hit rate is near 100%. You pay almost nothing after the first one.

Cap your context window

By default, OpenClaw sends the full conversation history with every request. Long sessions mean you're paying for thousands of lines of stale output on every single API call.

contextTokens: 80000        // hard cap on history per request
reserveTokensFloor: 24000   // prevents context-limit errors that trigger costly retries

A user on r/openclaw running 24/7 on a Raspberry Pi says this setting alone cut his overhead noticeably. Without it, OpenClaw's default behavior is to send everything, every time.

Set a budget cap right now

Before doing anything else: set a spending limit in your API provider's dashboard. Anthropic, OpenAI, and OpenRouter all support this. The difference between a $5 mistake and a $3,600 one is usually just a missing cap.

OpenRouter makes this especially easy - you can set a weekly credit limit with auto-reset. $10/week is a reasonable starting point.

Tier 2: Model routing (the biggest single win)

Running OpenClaw with a single frontier model for everything is the #1 cost mistake. This is where most of the 80%+ savings come from.

The idea is simple: cheap models handle routine tasks, expensive models only get called for complex ones. Most of your agent's work - checking email, sending reminders, answering basic questions - doesn't need Opus.

The community's go-to cheap models

These are what people are actually using as their default model, based on dozens of Reddit threads and YouTube guides:

• Minimax 2.5 - The most recommended budget model right now. Handles general tasks and brainstorming well. Dramatically cheaper than Sonnet or GPT-5.2.
• DeepSeek V3.2 / DeepSeek Reasoner - Strong for coding tasks. One commenter with 20 upvotes: "Just use DeepSeek Reasoner. It's so much cheaper than all the other frontier models and it's almost as good."
• Kimi K2.5 - One user dropped from $519/month on Sonnet 4.5 to ~$52 by switching to Kimi as their primary. That video has 31,000 views.
• GLM5 - Popular for coding alongside DeepSeek. Good output quality without the premium price tag.

How to set up model routing

OpenRouter is the standard approach - one API key, access to dozens of providers. Set your default to something cheap and configure fallbacks for when you need more firepower:

// Agent config
"primary": "openrouter/minimax/minimax-2.5"
"fallbacks": [
  "openrouter/deepseek/deepseek-v3.2",
  "anthropic/claude-sonnet-4-6"
]

The YouTuber running 19 agents for $6/month uses a three-tier system: Minimax 2.5 for general tasks, GLM5 or DeepSeek for coding, and Sonnet 4.5 only for writing. He uses the /model command to manually switch models mid-session when he hits something that actually needs a bigger brain.

Watch out for sub-agents

Here's a gotcha that catches people: when your agent spawns sub-agents for parallel work, they inherit your primary model. If your primary is Opus, every sub-agent runs on Opus. One user described this as "token bleed" in multiagent setups - your bill multiplies and you don't realize why.

Tier 3: Local models ($0 forever)

If you have a decent GPU, you can run most of your OpenClaw workload locally with zero API costs. Ollama became an official OpenClaw provider in March 2026, and the community has converged on a specific setup. There's also a community-maintained optimization guide on GitHub covering model selection, context management, and more.

Qwen3.5 27B: the community sweet spot

Almost every local-model guide points to Qwen3.5 27B as the best balance of quality and speed for OpenClaw. The 35b-a3b MoE variant runs at 112 tokens/second on an RTX 3090. It handles tool calling, which is the hard part - many smaller models can't. This recommendation comes from a highly upvoted guide on r/clawdbot (282 upvotes) that walks through the full setup.

The setup:

export OLLAMA_API_KEY="ollama-local"

// Agent config - important details:
"api": "ollama"                    // must be explicit
"primary": "ollama/qwen3.5:27b"
"reasoning": false                 // when enabled, sends "developer" role which Ollama can't handle

Critical gotcha the community learned the hard way: use the native Ollama API URL (localhost:11434), not the /v1 OpenAI-compatible path. The /v1 endpoint breaks tool calling, and tool calling is what makes OpenClaw actually useful.

The hybrid setup most people end up with

Pure local isn't great for everything. The approach that keeps coming up is a three-layer hybrid:

• 70% of tasks: Ollama / Qwen3.5 27B locally. Free.
• 25% of tasks: OpenRouter free tier models (Nemotron Ultra 253B, Llama 3.3 70B). Also free, with rate limits.
• 5% of tasks: Sonnet for the genuinely hard stuff. Maybe 5 calls a week.

Total cost for one user running this setup: $2.40/month. Only the Sonnet calls cost anything. The config uses cascading fallbacks so the agent automatically escalates when the cheaper model can't handle something.

The catch with free and local models

A student on r/openclaw spent two weeks trying to get OpenClaw running on free models and wrote a detailed post about how painful it was. Skills from ClawHub wouldn't work. Configs kept breaking. Models couldn't follow the skill instructions.

His conclusion: "Without Opus, I can practically do nothing or configure anything properly." That's an exaggeration - plenty of people make it work - but it captures something real. OpenClaw's skill system injects instructions into the context window. On models with 8K-32K context, skills can eat half your available space before you even send a message.

If you go the free/local route, keep your skill count low. Every installed skill adds context overhead.

Tier 4: The advanced tricks

Vector database for memory lookup

One of the highest-upvoted optimization posts on r/myclaw takes a completely different approach. Instead of sending your full memory file with every request, push your memories into a vector database (Qdrant, Chroma, Weaviate) and do nearest-neighbor search. Only the relevant slices get sent to the model.

The poster claims 90% token reduction on memory-heavy agents. Instead of sending 200-500 KB of memory on every call, you send 10-20 KB of actually relevant context. On Opus pricing, that's the difference between dollars per call and cents.

Offload work to n8n

Several guides recommend moving structured, repeatable tasks out of OpenClaw entirely. Things like "check this RSS feed every hour" or "send a Slack message when this webhook fires" don't need an LLM. They need a workflow tool.

n8n or even plain cron scripts can handle the deterministic stuff. Reserve OpenClaw for tasks that actually require reasoning. One commenter on the "5 settings" thread suggested this as the biggest structural change you can make: "Use n8n for orchestration, OpenClaw for intelligence."

Align heartbeat interval with cache TTL

This is a technical trick from the phantom token deep-dive. Anthropic's prompt cache has a TTL. If your heartbeat fires after the cache expires, you pay full price for the entire prompt. Set the interval to 55 minutes - just under the 1-hour cache window - and each heartbeat reuses the cached prompt from the last one.

The real scoreboard

Here's what these strategies actually look like in practice, pulled from public posts and videos:

The uncomfortable truth about all of this

Every optimization here works. People really are cutting their bills by 80-99%. But read that list again and count how many config changes, model decisions, and provider accounts are involved.

Model routing through OpenRouter. Heartbeat model overrides. Context token caps. Reserve token floors. Compaction mode tuning. Session TTLs. Memory flush thresholds. Cache-aligned intervals. Budget guardrails. Ollama configuration with specific API paths that break if you use the wrong endpoint.

That 19-agent guy spending $6/month? His YouTube video is 12 minutes of config walkthrough. The 97% reduction guide is 34 minutes. The "$0 OpenClaw" Reddit post is a wall of text with caveats and gotchas that took weeks to figure out.

And OpenClaw ships weekly. Any update can change default behavior, break a config setting, or introduce new background processes that burn tokens in ways you haven't accounted for. The optimization isn't a one-time thing. It's ongoing maintenance.

As one of OpenClaw's own maintainers put it: the defaults optimize for capability, not cost.

Or pay someone to solve it

Every optimization in this article is something a managed hosting service should handle for you. Heartbeat routing to cheap models. Context pruning. Session lifecycle management. Model selection per task type. Cache-aligned intervals. Budget protection. All of it, maintained across updates, without a 34-minute YouTube tutorial.

TryOpenClaw.ai runs your OpenClaw agent for $39/month. One price. No API keys to juggle, no config rabbit holes, no surprise bills. The optimization is built in.