SOP OpenClaw API cost reduction prompt
Full Credit to ScaleUp Media @mattganzak
OpenClaw
Token Optimization Guide
Reduce Your AI Costs by 97%
From $1,500+/month to under $50/month
WHAT YOU'LL ACHIEVE
97% Token Reduction • 5 Minutes to Implement • No Complex Setup
Free Local Heartbeat • Smart Model Routing • Session Management
ScaleUP Media
@mattganzak
Introduction
If you've been running OpenClaw and watching your API bills climb, you're not alone. The default configuration prioritizes capability over cost, which means you're probably burning through tokens on routine tasks that don't need expensive models.
This guide covers four key optimizations that work together to slash your costs:
Session Initialization — Stop loading 50KB of history on every message
Model Routing — Use Haiku for routine tasks, Sonnet only when needed
Heartbeat to Ollama — Move your heartbeat checks to a free local LLM
Rate Limits & Budgets — Prevent runaway automation from burning tokens
Why This Matters
Each optimization targets a different cost driver. Combined, they take you from $1,500+/month down to $30-50/month. That's money you can reinvest in actually building things.
Overall Cost Impact
Time Period
Before
After
Daily
$2-3
$0.10
Monthly
$70-90
$3-5
Yearly
$800+
$40-60
Part 1: Session Initialization
THE PROBLEM
Your agent loads 50KB of history on every message. This wastes 2-3M tokens per session and costs $4/day. If you're using third-party messaging or interfaces that don't have built-in session clearing, this problem compounds fast.
The Solution
Add this session initialization rule to your agent's system prompt. It tells your agent exactly what to load (and what NOT to load) at the start of each session:
SESSION INITIALIZATION RULE:
On every session start:
1. Load ONLY these files:
- SOUL.md
- USER.md
- memory/YYYY-MM-DD.md (if it exists)
2. DO NOT auto-load:
- Session history
- Prior messages
- Previous tool outputs
3. When user asks about prior context:
- Use memory_search() on demand
- Pull only the relevant snippet with memory_get()
- Don't load the whole file
4. Update memory/YYYY-MM-DD.md at end of session with:
- What you worked on
- Decisions made
- Leads generated
- Blockers
- Next steps
This saves 80% on context overhead.
Why This Works
Session starts with 8KB instead of 50KB
History loads only when asked
Daily notes become your actual memory
Works with any interface — no built-in session clearing needed
Results: Before & After
❌ BEFORE
✓ AFTER
50KB context on startup
8KB context on startup
2-3M tokens wasted per session
Only loads what's needed
$0.40 per session
$0.05 per session
History bloat over time
Clean daily memory files
No session management
Works with any interface
Part 2: Model Routing
Out of the box, OpenClaw typically defaults to using Claude Sonnet for everything. While Sonnet is excellent, it's overkill for tasks like checking file status, running simple commands, or routine monitoring. Haiku handles these perfectly at a fraction of the cost.
Step 1: Update Your Config
Your OpenClaw config file is located at:
~/.openclaw/openclaw.json
Add or update your config with these model settings:
{
"agents": {
"defaults": {
"model": {
"primary": "anthropic/claude-haiku-4-5"
},
"models": {
"anthropic/claude-sonnet-4-5": {
"alias": "sonnet"
},
"anthropic/claude-haiku-4-5": {
"alias": "haiku"
}
}
}
}
}
What This Does
Sets Haiku as your default model (fast and cheap) and creates easy aliases so your prompts can say "use sonnet" or "use haiku" to switch models on-demand.
Step 2: Add Routing Rules to System Prompt
MODEL SELECTION RULE:
Default: Always use Haiku
Switch to Sonnet ONLY when:
- Architecture decisions
- Production code review
- Security analysis
- Complex debugging/reasoning
- Strategic multi-project decisions
When in doubt: Try Haiku first.
Results: Before & After
❌ BEFORE
✓ AFTER
Sonnet for everything
Haiku by default
$0.003 per 1K tokens
$0.00025 per 1K tokens
Overkill for simple tasks
Right model for the job
$50-70/month on models
$5-10/month on models
Part 3: Heartbeat to Ollama
OpenClaw sends periodic heartbeat checks to verify your agent is running and responsive. By default, these use your paid API — which adds up fast when you're running agents 24/7. The solution? Route heartbeats to a free local LLM using Ollama.
Step 1: Install Ollama
If you don't already have Ollama installed, grab it from ollama.ai or run:
# macOS / Linux
curl -fsSL https://ollama.ai/install.sh | sh
# Then pull a lightweight model for heartbeats
ollama pull llama3.2:3b
Why llama3.2:3b?
It's lightweight (2GB), fast, and handles complex context better than 1b for production use
Step 2: Configure OpenClaw for Ollama Heartbeat
Update your config at ~/.openclaw/openclaw.json to route heartbeats to Ollama:
{
"agents": {
"defaults": {
"model": {
"primary": "anthropic/claude-haiku-4-5"
},
"models": {
"anthropic/claude-sonnet-4-5": {
"alias": "sonnet"
},
"anthropic/claude-haiku-4-5": {
"alias": "haiku"
}
}
}
},
"heartbeat": {
"every": "1h",
"model": "ollama/llama3.2:3b",
"session": "main",
"target": "slack",
"prompt": "Check: Any blockers, opportunities, or progress updates needed?"
}
Configuration Options
Option
Description
interval
Seconds between heartbeat checks (60 = once per minute)
provider
Set to "ollama" to use local LLM instead of paid API
model
Any Ollama model (llama3.2:1b is fast and tiny)
endpoint
Ollama's local API (default: http://localhost:11434)
Step 3: Verify Ollama is Running
# Make sure Ollama is running
ollama serve
# In another terminal, test the model
ollama run llama3.2:3b "respond with OK"
# Should respond quickly with "OK" or similar
Results: Before & After
❌ BEFORE
✓ AFTER
Heartbeats use paid API
Heartbeats use free local LLM
1,440 API calls/day (every minute)
Zero API calls for heartbeats
$5-15/month just for heartbeats
$0/month for heartbeats
Adds to rate limit usage
No impact on rate limits
Part 4: Rate Limits & Budget Controls
Even with model routing and optimized sessions, runaway automation can still burn through tokens. These rate limits act as guardrails to protect you from accidental cost explosions.
Add to Your System Prompt
RATE LIMITS:
- 5 seconds minimum between API calls
- 10 seconds between web searches
- Max 5 searches per batch, then 2-minute break
- Batch similar work (one request for 10 leads, not 10 requests)
- If you hit 429 error: STOP, wait 5 minutes, retry
DAILY BUDGET: $5 (warning at 75%)
MONTHLY BUDGET: $200 (warning at 75%)
Limit
What It Prevents
5s between API calls
Rapid-fire requests that burn tokens
10s between searches
Expensive search loops
5 searches max, then break
Runaway research tasks
Batch similar work
10 calls when 1 would do
Budget warnings at 75%
Surprise bills at end of month
Results: Before & After
❌ BEFORE
✓ AFTER
No rate limiting
Built-in pacing
Agent makes 100+ calls in loops
Controlled, predictable usage
Search spirals burn $20+ overnight
Max exposure capped daily
No budget visibility
Warnings before limits hit
Part 5: Workspace File Templates
Create these files in your workspace. They provide the essential context your agent needs while keeping the token footprint minimal.
SOUL.md Template
This file defines your agent's core principles and operating rules:
# SOUL.md
## Core Principles
[YOUR AGENT PRINCIPLES HERE]
## How to Operate
See OPTIMIZATION.md for model routing and rate limits.
## Model Selection
Default: Haiku
Switch to Sonnet only for: architecture, security, complex reasoning
## Rate Limits
5s between API calls, 10s between searches, max 5/batch then 2min break
USER.md Template
This file gives your agent context about you and your goals:
# USER.md
- Name: [YOUR NAME]
- Timezone: [YOUR TIMEZONE]
- Mission: [WHAT YOU'RE BUILDING]
## Success Metrics
- [METRIC 1]
- [METRIC 2]
- [METRIC 3]
Keep It Lean
Resist the urge to add everything to these files. Every line costs tokens on every request. Include only what the agent absolutely needs to make good decisions.
Part 6: Prompt Caching
90% Token Discount on Reused Content
THE PROBLEM
Your system prompt, workspace files (SOUL.md, USER.md), and reference materials get sent to the API with every single message. If your system prompt is 5KB and you make 100 API calls per week, that's 500KB of identical text being re-transmitted and re-processed every week. With Claude, you're paying full price for every copy.
THE SOLUTION
Prompt caching (available on Claude 3.5 Sonnet and newer) charges only 10% for cached tokens on re-use and 25% for cache writes. For static content you use repeatedly, this cuts costs by 90%.
How Prompt Caching Works
When you send content to Claude:
First request: Full price (1 token = $0.003)
Claude stores it in cache: Marked for reuse
Subsequent requests (within 5 minutes): 90% discount ($0.00003 per token)
What This Means
A 5KB system prompt costs ~$0.015 on first use, then $0.0015 on each reuse. Over 100 calls/week, you save ~$1.30/week just on system prompts.
Step 1: Identify What to Cache
✓ CACHE THESE
❌ DON'T CACHE
System prompts (rarely change)
Daily memory files (change frequently)
SOUL.md (operator principles)
Recent user messages (fresh each session)
USER.md (goals and context)
Tool outputs (change per task)
Reference materials (pricing, docs, specs)
Tool documentation (rarely updated)
Project templates (standard structures)
Step 2: Structure for Caching
OpenClaw automatically uses prompt caching when available. To maximize cache hits, keep static content in dedicated files:
/workspace/
├── SOUL.md ← Cache this (stable)
├── USER.md ← Cache this (stable)
├── TOOLS.md ← Cache this (stable)
├── memory/
│ ├── MEMORY.md ← Don't cache (frequently updated)
│ └── 2026-02-03.md ← Don't cache (daily notes)
└── projects/
└── [PROJECT]/REFERENCE.md ← Cache this (stable docs)
Step 3: Enable Caching in Config
Update ~/.openclaw/openclaw-config.json to enable prompt caching:
{
"agents": {
"defaults": {
"model": {
"primary": "anthropic/claude-haiku-4-5"
},
"cache": {
"enabled": true,
"ttl": "5m",
"priority": "high"
},
"models": {
"anthropic/claude-sonnet-4-5": {
"alias": "sonnet",
"cache": true
},
"anthropic/claude-haiku-4-5": {
"alias": "haiku",
"cache": false
}
}
}
}
}
Note
Caching is most effective with Sonnet (better reasoning tasks where larger prompts are justified). Haiku's efficiency makes caching less critical.
Configuration Options
Option
Description
cache.enabled
true/false — Enable prompt caching globally
cache.ttl
Time-to-live: "5m" (default), "30m" (longer sessions), "24h"
cache.priority
"high" (prioritize caching), "low" (balance cost/speed)
models.cache
true/false per model — Sonnet recommended, Haiku optional
Step 4: Cache Hit Strategy
To maximize cache efficiency:
1. Batch requests within 5-minute windows
Make multiple API calls in quick succession
Reduces cache misses between requests
2. Keep system prompts stable
Don't update SOUL.md mid-session
Changes invalidate cache; batch them during maintenance windows
3. Organize context hierarchically
Core system prompt (highest priority)
Stable workspace files
Dynamic daily notes (uncached)
4. For projects: Separate stable from dynamic
product-reference.md (stable, cached)
project-notes.md (dynamic, uncached)
Prevents cache invalidation from note updates
Real-World Example: Outreach Campaign
You're running 50 outreach email drafts per week using Sonnet (reasoning + personalization).
WITHOUT CACHING
WITH CACHING (BATCHED)
System prompt: 5KB × 50 = 250KB/week
System prompt: 1 write + 49 cached
Cost: $0.75/week
Cost: $0.016/week
50 drafts × 8KB = $1.20/week
50 drafts (~50% cache hits) = $0.60/week
Total: $1.95/week = $102/month
Total: $0.62/week = $32/month
SAVINGS: $70/month
Results: Before & After
❌ BEFORE
✓ AFTER
System prompt sent every request
System prompt cached, reused
Cost: 5KB × 100 calls = $0.30
Cost: 5KB × 100 calls = $0.003
No cache strategy
Batched within 5-minute windows
Random cache misses
90% hit rate on static content
Monthly reused content: $100+
Monthly reused content: $10
Single project: $50-100/month
Single project: $5-15/month
Multi-project: $300-500/month
Multi-project: $30-75/month
Step 5: Monitor Cache Performance
Check cache effectiveness with session_status:
openclaw shell
session_status
# Look for cache metrics:
# Cache hits: 45/50 (90%)
# Cache tokens used: 225KB (vs 250KB without cache)
# Cost savings: $0.22 this session
Or query the API directly:
# Check your usage over 24h
curl https://api.anthropic.com/v1/usage \
-H "Authorization: Bearer $ANTHROPIC_API_KEY" | jq '.usage.cache'
Metrics to Track
Metric
What It Means
Cache hit rate > 80%
Caching strategy is working
Cached tokens < 30% of input
System prompts are too large (trim)
Cache writes increasing
System prompt changing too often (stabilize)
Session cost -50% vs last week
Caching + model routing combined impact
Combining Caching with Other Optimizations
Caching multiplies the benefit of earlier optimizations:
Optimization
Before
After
With Cache
Session Init (lean context)
$0.40
$0.05
$0.005
Model Routing (Haiku default)
$0.05
$0.02
$0.002
Heartbeat to Ollama
$0.02
$0
$0
Rate Limits (batch work)
$0
$0
$0
Prompt Caching
$0
$0
-$0.015
COMBINED TOTAL
$0.47
$0.07
$0.012
When to NOT Use Caching
Haiku tasks (too cheap to cache): Caching overhead > savings
Frequent prompt changes: Cache invalidation costs more than caching saves
Small requests (< 1KB): Caching overhead eats the discount
Development/testing: Too many prompt iterations; cache thrashing
Best Practices Checklist
Batch requests within 5-minute windows
Keep reference docs in separate cached files
Monitor cache hit rate (target: > 80%)
Combine caching with model routing (Sonnet + cache = max savings)
Update system prompts during maintenance windows, not live
Document cache strategy in TOOLS.md for consistency
The Bottom Line
Prompt caching is effortless cost reduction. With minimal setup, you get 90% discounts on content you're already sending. Combined with the other five optimizations, you go from $1,500+/month to $30-50/month.
Verifying Your Setup
After making these changes, verify everything is working correctly:
Check Your Configuration
# Start a session
openclaw shell
# Check current status
session_status
# You should see:
# - Context size: 2-8KB (not 50KB+)
# - Model: Haiku (not Sonnet)
# - Heartbeat: Ollama/local
Signs It's Working
Context size shows 2-8KB instead of 50KB+
Default model shows as Haiku
Heartbeat shows Ollama/local (not API)
Routine tasks complete without switching to Sonnet
Daily costs drop to $0.10-0.50 range
Troubleshooting
Context size still large → Check session initialization rules are in system prompt
Still using Sonnet for everything → Verify config.json syntax and path
Heartbeat errors → Make sure Ollama is running (ollama serve)
Costs haven't dropped → Check your system prompt is being loaded
Quick Reference Checklist
Use this checklist to make sure you've completed all the steps:
SESSION INITIALIZATION
☐
Added SESSION INITIALIZATION RULE to system prompt
MODEL ROUTING
☐
Updated ~/.openclaw/openclaw.json with model aliases
☐
Added MODEL SELECTION RULE to system prompt
HEARTBEAT TO OLLAMA
☐
Installed Ollama and pulled llama3.2:1b
☐
Added heartbeat config pointing to Ollama
☐
Verified Ollama is running (ollama serve)
RATE LIMITS & WORKSPACE
☐
Added RATE LIMITS to system prompt
☐
Created SOUL.md with core principles
☐
Created USER.md with your info
☐
Verified with session_status command
The Bottom Line
No complex setup. No file management scripts. Just smart config, clear rules in your system prompt, and a free local LLM for heartbeats. The intelligence is in the prompt, not the infrastructure.
Questions? DM me @mattganzak
