Why Clawdbot Burns Millions of Tokens and How to Slash Its Costs

1. Shocking Token Consumption Data

Scenario                     Token Consumption   Cost      Frequency
---------------------------------------------------------------
Basic conversation init      ~14,500 tokens      $0.04‑0.05  per request
Simple query (no cache)      ~15,000 tokens      $0.055     per request
Multi‑turn tool task         100k‑500k tokens    $0.30‑1.50 per task
Complex workflow (loops)     >1,000,000 tokens   $3‑10      per task
Extreme case (Fed. Viticci)  180,000,000 tokens ~$540       per week
Out‑of‑control (HackerNews)  ~10,000,000 tokens $300+       in 2 days

2. Architecture Dissection: Four Token Black Holes

2.1 Fixed System Prompt Overhead

Every interaction rebuilds a massive system prompt (~14k tokens) that includes core identity, tool definitions, skills metadata, injected files, runtime metadata, and response format instructions. This fixed cost is sent in full for every API call, causing a baseline expense of $0.04‑0.05 per request.

System Prompt Structure (~14,000 tokens)
├── Core identity (~500 tokens)
│   └── "You are Moltbot, a personal AI assistant..."
├── Tool definition list (~8,000 tokens)   ← largest overhead
│   ├── bash tool (400 tokens)
│   ├── browser tool (500 tokens)
│   ├── file_system tool (450 tokens)
│   ├── memory_search tool (300 tokens)
│   └── … (20+ tools, each 300‑500 tokens)
├── Skills metadata (~1,500 tokens)
├── Injected files (~2,000 tokens)
│   ├── AGENTS.md
│   ├── SOUL.md
│   ├── TOOLS.md
│   └── USER.md
├── Runtime metadata (~500 tokens)
│   ├── Current time/zone
│   ├── Host info
│   └── Model config
└── Reply format instructions (~1,500 tokens)

2.2 ReAct Loop Token Accumulation

Clawdbot uses a ReAct (Reasoning + Acting) cycle, where each turn adds new tokens from thoughts, actions, observations, and tool results. The token count grows quadratically with the number of iterations.

ReAct loop example (three turns)
Turn 1: Input 14,050 tokens → Output 300 tokens → Cumulative 14,350
Turn 2: Input 16,350 tokens → Output 400 tokens → Cumulative 16,750
Turn 3: Input 19,750 tokens → Output 800 tokens → Cumulative 20,550
Total ≈ 50,000+ tokens for a single three‑turn task

Mathematically, if n is the number of iterations, S the system prompt size, and a the average new tokens per turn, total tokens ≈ S·n + a·n(n+1)/2 , which explains the observed quadratic growth.

2.3 Tool Execution Result Feedback Inflation

Tool Type          Typical Output Size      Token Estimate
----------------------------------------------------------
Web page fetch     Full HTML page           5,000‑20,000
File read          Code file / logs         1,000‑10,000
Database query     Result set               2,000‑15,000
Shell command      Command output           500‑5,000
API call           JSON response            1,000‑8,000
Search results     Summarized entries      2,000‑10,000

Even when only a small fragment of the result is needed, the entire output is fed back to the LLM, inflating the context.

2.4 Reflex Loops Penalty Mechanism

When errors occur, Clawdbot enters a reflex (self‑correction) loop, repeatedly planning, acting, reflecting, and retrying. This not only adds direct token cost but also degrades reasoning quality, triggering more errors—a cost‑death spiral.

No reflex: ~12,800 tokens per task

3‑round reflex: ~45,000 tokens per task (3.5×)

5‑round reflex: ~136,000 tokens per task (10.6×)

7‑round reflex: ~172,000 tokens per task (13.4×)

3. Why These Issues Are Hard to Avoid

3.1 All‑or‑Nothing Context Window

Every request must resend the full context; incremental updates are impossible.

Changing a single parameter still requires the entire system prompt.

Even a brief follow‑up question carries the whole conversation history.

Partial tool results must still be sent in full.

3.2 Agentic Design Overthinking

Default activation of 20+ tools instead of on‑demand loading.

Full conversation history retained without summarisation.

Strongest model (Claude Opus) used by default, ignoring cheaper alternatives.

3.3 Lack of Built‑in Cost Constraints

No per‑request token ceiling.

No task‑level token quota.

No automatic model downgrade when context grows.

4. Strategies to Control Your Token Bill

4.1 Enable Prompt Caching (up to 90% cost cut)

# config.yaml
agents:
  defaults:
    model:
    params:
      cacheControlTtl: "1h"   # cache for 1 hour
    heartbeat:
      every: "55m"            # refresh before expiry

First request: ~1.25× base cost (writes cache).

Subsequent requests: ~0.1× base cost (reads cache).

Overall savings: 60‑95%, larger for longer dialogs.

4.2 Use Lobster Workflow Engine (60‑95% savings)

# YAML workflow replacing ReAct loop
workflow:
  name: flight_booking
  steps:
    - tool: browser.search
      input: "flights NYC to LAX {{date}}"
    - tool: code.compare_prices
      input: "{{previous_result}}"
    - tool: api.book
      input: "{{best_option}}"

By converting iterative LLM reasoning into a deterministic tool chain, the quadratic token cost of ReAct is eliminated.

4.3 Context Compaction (Compression)

# Manual trigger
/compact

# Automatic compaction when >50k tokens
agents:
  defaults:
    memory:
      autoCompaction:
        enabled: true
        tokenThreshold: 50000
        interval: 1800   # check every 30 minutes

Summarises history to key points, cutting 70‑90% of context tokens.

4.4 Prune Tool Set and Lazy Load

# Load only essential tools
agents:
  defaults:
    tools:
      enabled:
        - bash
        - file_read
        - memory_search
      disabled:
        - browser   # enable manually when needed
        - api_call

Reducing the tool count from 20+ to 5‑8 core tools can shrink the system prompt by 50‑60%.

4.5 Model Routing Strategy

# Choose model based on task complexity
agents:
  defaults:
    model:
      routing:
        simple_queries: "claude-sonnet-4"   # fast, cheap
        tool_execution: "claude-sonnet-4"   # balanced
        complex_reasoning: "claude-opus-4-5" # powerful but costly

Claude Opus 4.5: $15 per 1M output tokens

Claude Sonnet 4: $3 per 1M output tokens

≈5× price gap → proper routing can save ~80% of cost.

GitHub repository: https://github.com/openclaw/openclaw