Why Your OpenClaw Agent Is Spending More Than You Think (And How to Fix It)

The Real Cost Breakdown

Let's put actual numbers on this. OpenClaw costs come from three places: your AI provider, your infrastructure, and how you've configured your agent to behave.

Ollama (Local Models) — $0/month

If you're running models locally via Ollama, your API cost is zero. Models like Llama 3.1, Mistral, and Phi-3 run entirely on your hardware. The cost is your electricity and compute — negligible for most users. The tradeoff is capability: local models are slower and less powerful than Claude or GPT-4 for complex reasoning tasks.

Best for: lightweight tasks, file reads, simple lookups, anything that doesn't require heavy reasoning.

Cloud API Providers — $10–$200+/month

The per-token cost varies enormously by model:

• Claude Haiku 3.5: ~$0.80 per million input tokens / $4 per million output tokens
• Claude Sonnet 3.7: ~$3 per million input tokens / $15 per million output tokens
• GPT-4o mini: ~$0.15 per million input tokens / $0.60 per million output tokens
• GPT-4o: ~$2.50 per million input tokens / $10 per million output tokens

A typical single-turn conversation (one prompt, one response) costs fractions of a cent. That's not the problem. The problem is what agentic workflows do to that math.

What Agentic Loops Actually Cost

When OpenClaw runs an autonomous task — say, "research this topic and write a summary" — it doesn't make one API call. It makes many. Each step adds the previous conversation to the context window. By step 8 of a research loop, your input tokens might be 10,000+ just from accumulated context. Then it outputs. Then repeats.

Example: A 12-step research-and-write task using Claude Sonnet, starting with a 2,000-token context that grows by ~1,500 tokens per step:

• Total input tokens: ~90,000 (growing context across 12 calls)
• Total output tokens: ~18,000
• Cost: ~$0.54 — for one task that took 3 minutes

That's not catastrophic. But run 5 tasks like that per day for a month and you're at $80+ just from those tasks. Add memory writes, tool calls, and background cron jobs — and $150+ is easy.

VPS + API Combined Scenarios

If you're running OpenClaw on a VPS (DigitalOcean, Hetzner, etc.), add that cost too:

• Minimal VPS (2GB RAM): ~$6–12/month
• With Ollama + decent performance (8GB RAM): ~$20–40/month
• Full agent stack, heavy usage (16GB RAM): ~$48–80/month

A mid-range setup — decent VPS + moderate Sonnet usage — lands you at $70–120/month without any red flags. Heavy usage pushes past $200.

The 4 Things That Spike Your Bill Without Warning

These are the patterns we see most often in OpenClaw setups that generate unexpectedly high bills. None of them are obvious from the default configuration.

1. Autonomous Task Loops With No Exit Condition

OpenClaw is designed to run autonomously. That's the point. But "autonomous" without a ceiling means an agent can loop indefinitely if it hits an ambiguous state — or if it's overly thorough. A task that should take 5 steps can stretch to 20 if the model keeps deciding there's more to do.

The fix: Set explicit max-step limits in your agent configs. A task shouldn't be able to call tools more than 10–15 times without a human checkpoint.

2. Memory Writes That Compound Over Time

Every time OpenClaw writes to memory (persisting facts about you, your preferences, project context), it often reads memory first to avoid duplication. That means memory writes involve both read tokens (loading existing memory) and write tokens (the new content). If your agent is memory-heavy and runs frequently, you're paying for memory operations on every session.

The fix: Audit what your agent is actually persisting. Memory should store high-value, frequently-reused context — not ephemeral task notes that get read once and never used again.

3. Tool Calls That Cascade Into More Tool Calls

Web search is the classic example. Your agent searches for something. The results mention something interesting. The agent decides to search for that too. Now you have 3 searches instead of 1 — and each search result gets added to the context window before the next call.

This isn't a bug. The agent is being thorough. But without constraints, "thorough" becomes expensive fast.

The fix: Set tool call budgets per task. Web search should have a max invocation count per session. Same for any tool that generates large outputs.

4. Poorly Scoped Context Windows

The context window is everything the model sees when it generates a response. If you're loading large files, long conversation histories, or extensive memory into context on every call — even when that information isn't needed — you're paying for tokens that don't contribute to the output.

Context window bloat is silent. You won't see it unless you're actively inspecting token counts.

The fix: Use summarization for long histories. Load files selectively, not in bulk. Set a context cap that forces pruning before every call.

How to Audit Your Current Spend

Before you change anything, you need to know where your money is actually going. Here's how to find out.

Step 1: Check Your Provider Dashboard

• Anthropic: console.anthropic.com → Usage. Shows daily token usage by model. Look for spikes — specific days where usage jumped.
• OpenRouter: openrouter.ai/activity. Per-request logs with token counts and costs. You can filter by model and date range.
• OpenAI: platform.openai.com → Usage. Same pattern — daily breakdown by model.

What you're looking for: consistent high usage (probably fine — that's normal load) vs. irregular spikes (indicates runaway loops or unexpected autonomous tasks).

Step 2: Inspect OpenClaw Logs

OpenClaw logs each session with model and token information. Check recent logs:

# View recent session logs
ls -lt ~/.openclaw/logs/ | head -20

# Search for token usage across recent logs
grep -r "tokens" ~/.openclaw/logs/ | tail -100

# Find the most expensive recent sessions
grep -r "total_tokens" ~/.openclaw/logs/ | sort -t: -k3 -rn | head -20

Sessions with high total_tokens that you don't remember initiating are the ones to investigate. Check the corresponding log file for what the agent actually did.

Step 3: Set Spend Limits Before You Change Anything Else

Before tuning your config, put a ceiling in place so you're protected while you experiment:

• Anthropic Console: Settings → Limits → Set monthly spend cap ($25–50 is a good starting point)
• OpenRouter: API Keys → Edit key → Set credit limit per key

A spend cap won't fix the underlying issue, but it means a misconfiguration can't spiral into a $300 bill while you figure things out.

Configuration Fixes That Actually Move the Needle

These are the specific changes that make the biggest difference. In order of impact:

1. Route Lightweight Tasks to Haiku (or Local)

Most OpenClaw tasks don't need your most powerful model. Calendar lookups, file reads, simple web searches, status checks — Haiku handles all of these well at a fraction of the cost.

In your OpenClaw agent config:

# ~/.openclaw/workspace/AGENTS.md or agent config
# Specify model per task type

# For lightweight ops (search, read, status)
model: anthropic/claude-haiku-3-5

# For reasoning-heavy tasks (analysis, writing, planning)
model: anthropic/claude-sonnet-3-7

If you're using OpenRouter, you can set per-model fallbacks and route based on task complexity. The switching overhead is minimal — the cost savings are substantial.

2. Set Rate Limits and Session Caps

Add hard limits to prevent runaway sessions:

# In your openclaw config or session settings:

# Max tool calls per task (prevents cascading loops)
max_tool_calls_per_session: 15

# Max tokens per session (forces context pruning)
max_context_tokens: 32000

# Session timeout (kills stalled sessions)
session_timeout_minutes: 30

These limits feel restrictive until you realize that most tasks finish well within them — and the ones that don't are usually loops that shouldn't be running unchecked anyway.

3. Prune Context Windows Aggressively

Long conversation histories are expensive. If your agent maintains a running context across sessions, it's loading that history into every call — even when it's not relevant.

# Enable context summarization to compress old history
context_strategy: summarize_on_overflow

# Set max context before summarization triggers
context_window_target: 20000

# Don't auto-load all memory on every session
memory_load_mode: selective  # vs. eager

Summarization compresses old context into a short summary instead of loading full transcripts. The model loses some detail, but for most tasks that's acceptable — and it can cut your input token count by 60–70%.

4. Audit and Trim Your Agent's System Prompt

Every API call includes your system prompt in the input tokens. A 3,000-token system prompt gets charged on every single call. Across 200 sessions per month, that's 600,000 extra tokens — just from setup instructions.

Review your SOUL.md, AGENTS.md, and any injected context files. Trim aggressively. Remove anything the model doesn't actively use. 800–1,200 tokens is the target for a lean system prompt.

5. Disable Cron Jobs You Don't Need

OpenClaw supports background cron tasks — scheduled agents that run automatically. These are powerful and also invisible cost generators. Check what's running:

# List active cron configurations
cat ~/.openclaw/config.yaml | grep -A 20 "cron"

# Check recent cron session logs
ls -lt ~/.openclaw/logs/ | grep "cron" | head -20

Disable any cron jobs you didn't intentionally set up, or that aren't delivering value proportional to their cost. A cron job running every hour with Claude Sonnet adds up fast.

Getting all of this right takes time — finding the config options, testing the limits, calibrating what's acceptable to trade off. If you'd rather skip the tuning and get a configuration that reflects current best practices for cost-conscious OpenClaw usage, that's exactly what ClawMentor's update packages deliver.