Cost Optimization

The most common mistake is treating OpenClaw like a single super-intelligent chatbot that should handle everything at once. Conversation, planning, research, coding, memory, task tracking, monitoring. All through one model, all the time.

That setup ends in endless follow-up questions, permission loops, silent failures and burned quotas. When it works, it's expensive. When it breaks, it's hard to tell why.

What clicked was that the main model should be a coordinator, not a worker. The default agent should be capable but not overkill. Expensive models stay out of the hot path. A config along these lines:

"agents": {
  "defaults": {
    "model": {
      "primary": "anthropic/claude-sonnet-5-5",
      "fallbacks": [
        "kimi/k3-256k",
        "zai/glm-5.3",
        "google/gemini-3.8-flash",
        "openai/gpt-6-luna",
        "google/gemini-3.5-flash-lite"
      ]
    },
    "utilityModel": "openai/gpt-6-luna"
  }
}

The exact model list matters less than the intent. Expensive models aren't sitting in the default loop, and fallback behavior is explicit. utilityModel moves short internal jobs, like session titles and progress narration, onto a small model too.

Auto-mode and blind routing look good early on. Both are worth dropping. Note that OpenRouter onboarding defaults to openrouter/auto, so if you set up through OpenRouter, replace it with a concrete model once you know what you need.

Letting the system decide which model to use sounds great. In practice it leads to indecision, unexpected cost spikes, and behavior you can't reason about when something goes wrong.

Being explicit works better. Default routing stays cheap and predictable. Agents get pinned to specific models for specific jobs. When something expensive runs, it's because you asked for it.

High-quality models like Claude Opus 5.5 or GPT-6.1 Sol are useful. They're great at restructuring prompts, designing agents, reasoning through messy problems, and fixing things that are already broken.

Where it burns you is leaving that level of model running all day. It feels powerful until you hit rate limits and get locked out waiting for quotas to refresh. At that point you're not building anything. You're just waiting.

There's a lot of hype around buying Mac minis or Mac Studios just to run OpenClaw. Don't do it early.

Not everyone has $600 to drop on a tool, and even if you do, it's usually the wrong first move. The FOMO is real, and it's easy to feel like you need dedicated hardware immediately.

Learn your workflow first. Learn your costs. Figure out your failure modes. Then decide whether hardware is worth it.

Local models get pitched as the solution to everything. The math rarely works out unless you already have serious hardware. Hardware prices as of early 2026:

$9,000+

Mac Studio, 512 GB unified memory, 2 TB

~$18,000

Two Mac Studios to host a Kimi-class open model usably

Unless you're building a business that needs that hardware for more than OpenClaw, skip it.

Local models are fine for experiments and simple tasks. But bending over backwards to save a few cents usually costs more in lost time and degraded performance than paying for API calls.

There's a lot of hype around OpenClaw: flashy demos, videos promising it will replace everything you do, "this changes everything" energy on every platform. Plenty of people spend more time configuring OpenClaw than doing the work they wanted it to help with.

Resist the FOMO and ignore most of that content. A lot of it is optimized for clicks, not for the boring Tuesday-afternoon usage that actually matters.

One of the bigger mental shifts is realizing how cheap some models are when used well.

Heartbeats run often but do simple checks. There's no reason to burn premium models on background plumbing: tens of thousands of heartbeat tokens cost fractions of a cent on cheap models.

For specific model picks and the cost math, see the Config Reference chapter.

Concurrency limits matter for cost control too. Left unset, maxConcurrent now scales with your CPU (at least 8, and 4 per core), which is generous on a big VPS. Each session can also run 8 sub-agents at once, with no timeout by default. Pin all three:

"agents": {
  "defaults": {
    "maxConcurrent": 4,
    "subagents": {
      "model": "google/gemini-3.8-flash",
      "maxConcurrent": 4,
      "runTimeoutSeconds": 900
    }
  }
}

Those limits stop one bad task from cascading into retries and runaway cost. subagents.model keeps spawned helpers on a cheap model while the main agent stays on a stronger one.

Not everything has to go through APIs. In the original author's setup (early 2026), two coding subscriptions at about $20 each covered most of the work, and API usage added about $5–10 a month split between OpenRouter and OpenAI. Prices move; the shape of the budget is what to copy.

If you let agents run nonstop, allow unlimited retries, or route everything through premium models, costs climb. People hit $200+ in a weekend by leaving things uncapped.

Scope models, cap concurrency and keep background work on cheap models, and costs flatten out fast. Check what you're actually spending instead of guessing:

# In chat: local cost summary from session logs
/usage cost

# From the terminal, against the running Gateway
openclaw gateway usage-cost