OpenClaw Token Optimization: Cut AI Agent Costs by 97%

Prompt 1: Generate Token Audit Script

I'm running OpenClaw and need to audit my token usage to find waste.

Generate a Python script that:

1. READS: OpenClaw log files from [SPECIFY YOUR LOG DIRECTORY]
2. EXTRACTS: Token usage data by category
3. CALCULATES:
   - Context size per operation type
   - Session history loading frequency and size
   - Heartbeat token usage
   - Model routing distribution
   - Daily/weekly cost projections

4. OUTPUTS:
   - Summary dashboard with key metrics
   - Top 5 waste sources ranked by cost
   - Before/after projection if waste eliminated
   - CSV export for tracking over time

5. HANDLES:
   - Different log formats
   - Missing data gracefully
   - Rate limit errors separately

Generate complete, documented script ready to run.
Include installation instructions for dependencies.

Prompt 2: Analyze Audit Results

I ran a token audit on my OpenClaw instance. Help me interpret the results and prioritize fixes.

MY AUDIT RESULTS:
[Paste your audit output here]

Analyze and provide:

1. TOP 3 WASTE SOURCES:
   - Rank by cost impact
   - Estimate savings % if eliminated
   - Difficulty to fix (easy/medium/hard)

2. QUICK WIN IDENTIFICATION:
   - What can I fix in <30 min for biggest impact?
   - Which fixes are prerequisites for others?

3. PRIORITIZED FIX SEQUENCE:
   - Step 1: [Fix + expected savings]
   - Step 2: [Fix + expected savings]
   - Step 3: [Fix + expected savings]

4. RED FLAGS:
   - Any unusual patterns?
   - Signs of misconfiguration?
   - Potential security issues?

Prompt 1: Generate Context Management Config

I'm running OpenClaw and need to eliminate context bloat.

CURRENT SITUATION:
- Every heartbeat loads full context (~50KB+)
- Every message loads all context + history
- Context size growing: 50KB → 75KB → 100KB+

MY CURRENT CONFIG:
[Paste your config.json here OR say "using default config"]

GOAL:
Generate modified config that:
1. Prevents context loading on heartbeats
2. Implements selective context loading by task type
3. Reduces typical operation from 50KB → <10KB
4. Maintains necessary context for task completion
5. Preserves agent functionality

OUTPUT:
- Complete modified config.json
- Explanation of each changed parameter
- Test procedure to verify context reduction
- Rollback instructions if something breaks

CRITICAL: Don't break the agent. Preserve task completion capability.

Prompt 2: Verify Context Reduction

I just modified my OpenClaw config to reduce context bloat.

Run this verification checklist:

1. AUDIT COMPARISON:
   Before config: [Your Step 0 context size]
   After config: [Your new audit context size]
   Reduction: ____%

2. FUNCTIONALITY TEST:
   - Can agent complete simple task? (Y/N)
   - Can agent access memory when needed? (Y/N)
   - Any error messages? [List them]

3. NEXT STEPS:
   - If reduction <50%: [What to check/fix]
   - If agent broke: [Rollback procedure]
   - If reduction >70%: [Proceed to Step 2]

Analyze my results and tell me if I'm good to proceed.

MY RESULTS:
[Paste audit comparison here]

MATT'S IMPLEMENTATION:

Discovery: Token audit showed 50KB context per heartbeat
Fix Applied: Selective context loading config
Test: Simple task completion verified
Result: 50KB → 5KB (90% reduction)
Savings: $3/day → $0/day idle
Time: 15 min config + 5 min test

Key Learning: Rate limits forced him to investigate. Most users never look at token breakdown and just accept the cost.

Prompt 1: Generate Session Cleanup Command

I'm running OpenClaw with Slack integration and it's loading my entire Slack history (111KB) on every message.

CREATE: A custom OpenClaw command called "new_session" that:

FUNCTIONALITY:
1. Dumps current Slack/WhatsApp session buffer
2. Saves dumped content to agent memory (accessible for recall)
3. Clears the session buffer completely
4. Confirms cleanup completed with token savings estimate

TECHNICAL REQUIREMENTS:
- Callable by typing "new session" in Slack
- Memory format allows selective recall if needed
- No loss of critical information
- Immediate effect on next API call
- Logs the action for audit trail

OUTPUT:
- Complete command code (ready to integrate)
- Installation/integration instructions for OpenClaw
- Usage examples and best practices
- Verification method (how to confirm it worked)
- Expected token savings per operation after cleanup

PLATFORM: [Slack / WhatsApp / Other]

Prompt 2: Session History Audit

Help me verify session history is my token waste culprit.

MY TOKEN AUDIT SHOWS:
[Paste relevant audit sections]

Analyze:
1. Is session history loading the issue?
   - Expected indicators: [What to look for in logs]
   - Platform comparison: Does web UI show same pattern?

2. Estimated impact:
   - Current waste from session history: $___/day
   - Potential savings if fixed: $___/day

3. Verification procedure:
   - How do I confirm session dump worked?
   - What should audit show after fix?

4. Alternative causes:
   - If it's NOT session history, what else could cause this pattern?

MATT'S SESSION HISTORY DISCOVERY:

Problem: Hitting rate limits (429 errors) constantly
Investigation: Compared web UI vs Slack token usage
Finding: Slack used 1M+ tokens, web UI used 50k for SAME task
Root cause: 111KB session history blob in every Slack API call
Fix: Created "new session" command
Result: Rate limits eliminated, token usage normalized
Time: 20 min to build command, 2 min to use

Critical Insight: Would never have found this without rate limits forcing investigation. Silent killer for Slack users.

Prompt 1: Configure Olama Integration

I want to add Olama (local LLM) to my OpenClaw setup to eliminate API costs for brainless operations.

CURRENT SETUP:
[Paste your current OpenClaw config.json]

GOAL:
Generate config modifications to:

1. ADD OLAMA:
   - Model: [Latest Olama version - currently llama2]
   - Use for: heartbeats, file_ops, csv_compile, folder_structure
   - Cost tier: FREE
   - Routing: Default for "brainless" task category

2. UPDATE HEARTBEAT:
   - Route all heartbeats to Olama
   - Remove API calls entirely
   - Maintain check frequency (30 min)
   - Preserve functionality

3. TESTING:
   - How to verify Olama is handling heartbeats
   - How to confirm zero API calls
   - Fallback if Olama fails

OUTPUT:
- Complete modified config.json
- Olama installation verification steps
- Integration test procedure
- Troubleshooting common issues

Make it copy-paste ready.

Prompt 2: Identify "Brainless" Operations

Help me identify which of my OpenClaw operations should run on Olama (free) vs API models (paid).

MY TYPICAL TASKS:
[List your common agent tasks here]

For each task, classify as:

1. BRAINLESS (Olama - Free):
   - No reasoning required
   - File/data manipulation only
   - Pattern matching at most

2. LOW-COMPLEXITY (Haiku - $0.25/1M):
   - Basic research/collection
   - Simple formatting with light intelligence

3. MEDIUM-COMPLEXITY (Sonnet - $3/1M):
   - Writing, email drafting
   - Code generation

4. HIGH-COMPLEXITY (Opus - $15/1M):
   - Strategic reasoning
   - Novel problem solving

Then estimate my cost savings routing everything optimally.

MATT'S OLAMA IMPLEMENTATION:

Problem: Spending $2-3/day on heartbeats alone (Sonnet)
Solution: Installed Olama, routed heartbeats to local
Test: Let it run overnight, checked logs
Result: Zero API calls for heartbeats confirmed
Savings: $2-3/day → $0/day on heartbeats

Extended Use Cases Matt Found:
- File organization during overnight jobs (14 sub-agents)
- CSV compilation from multiple sources
- Folder structure creation
- Log parsing and cleanup

Total Olama Usage: ~15% of all operations
Total Savings: These operations would have cost $20-30/month
Actual Cost: $0 forever

Installation Time: 10 min
Config Time: 15 min
ROI: Infinite (free forever)

Prompt 1: Generate Multi-Model Routing Config

I want to set up 4-tier model routing in OpenClaw to automatically use cheapest viable model for each task.

CURRENT SETUP:
[Paste your config.json]

MY TASK BREAKDOWN:
[Describe your common operations and their complexity]

GOAL:
Create complete multi-model routing configuration:

TIER 0 - OLAMA (Free):
- Tasks: heartbeats, file_ops, csv_compile, folder_structure
- Escalation: None (if fails, log error)

TIER 1 - HAIKU ($0.25/1M):
- Tasks: data_collection, web_scrape, list_building, basic_formatting
- Escalation: Sonnet (if blocked or error)
- Default tier: Use unless explicitly routed elsewhere

TIER 2 - SONNET ($3/1M):
- Tasks: writing, email_draft, code_gen, research_synthesis
- Escalation: Opus (if blocked or error)

TIER 3 - OPUS ($15/1M):
- Tasks: strategic_reasoning, complex_logic, novel_problems
- Escalation: None (final tier)

OUTPUT:
- Complete routing config (JSON)
- Task classification rules
- Escalation logic implementation
- Test procedure for each tier
- Expected cost distribution

Make it production-ready and well-documented.

Prompt 2: Sub-Agent Orchestration

I want to create a sub-agent orchestration system for complex overnight batch jobs.

USE CASE:
[Describe your overnight job - e.g., B2B lead gen]

REQUIREMENTS:
- Spin up multiple specialized sub-agents
- Each routed to appropriate model tier
- Parallel execution where possible
- Results aggregated and organized
- Target: <$2/hour for full operation

DESIGN:
1. Agent Specialization:
   - How many sub-agents needed?
   - What does each specialize in?
   - Which model tier per agent?

2. Coordination:
   - Master agent responsibilities
   - Sub-agent communication
   - Error handling and escalation

3. Cost Optimization:
   - Task distribution for minimal cost
   - Cached token maximization
   - Parallel vs sequential trade-offs

OUTPUT:
- Sub-agent architecture diagram
- Task distribution algorithm
- Complete implementation code
- Test procedure (100-item trial)
- Scaling guidelines (1,000+ items)

Task: 1,000 Qualified B2B Leads

Agents 1-10 (Haiku):
  Web scraping distressed business signals
  Reading blogs and finding contact info
  Using Brave Search API + Hunter.io
  4 hours runtime

Agents 11-12 (Sonnet):
  Writing personalized cold outreach emails
  Creating follow-up sequences
  1.5 hours runtime

Agents 13-14 (Olama):
  Organizing files into folders
  Compiling CSVs with proper headers
  0.5 hours runtime

RESULTS:
Total Cost: $6 for 6 hours
Per-hour: $1
Per-lead: $0.006

If run on Opus only: $150
If run on Sonnet only: $30
Savings: 96% vs Opus, 80% vs Sonnet

Key Insight: 95% of tokens were CACHED (repeated operations), further reducing cost. Caching + multi-model routing = production economics.