OpenClaw is expensive — why the agent burns through tokens and how to save

OpenClaw is an autonomous agent with a multi-tiered architecture. Unlike simple assistants, where a single prompt goes into the model and an answer comes back, OpenClaw builds a chain of several roles and several iterations. Every link in the chain consumes tokens, and the total cost per user task is an order of magnitude or more than what a chat assistant burns.

A typical OpenClaw workflow on the task "write module X":

1. Planner reads the task description and the entire project context (~30K input + 2K output)
2. Decomposer splits the plan into sub-tasks (~20K input + 1K output)
3. Executor for each sub-task: reads files, generates code, applies patches (5—15 iterations × ~50K input + 3K output)
4. Critic reviews the results and suggests corrections (~40K input + 2K output)
5. Corrector applies the fixes (5—10 iterations × ~30K input + 2K output)
6. Final review and report formatting (~30K input + 1.5K output)

Add it all up — one average OpenClaw task eats 800K—1.5M input tokens and 50—120K output tokens. On complex tasks with long autonomous iterations, consumption climbs to 5—15M input + 200—500K output.

Real numbers for specific task types:

• Simple feature (one function with a test): ~600K total tokens ≈ $3 on Anthropic
• Medium feature (a new 200-line module): ~3M total tokens ≈ $12
• Complex feature (refactoring + new functionality): ~10M total tokens ≈ $35
• Long autonomous task (an hour-long run with a critic and iterations): 30—50M total tokens ≈ $100—170
• A full day of the agent with several tasks in OpenClaw: 100—200M total tokens ≈ $350—700

The key difference from Cline or Cursor is that OpenClaw makes 3—5 role calls at every step, while Cline makes one. This isn't a bug — it's a feature that improves decision quality and reduces the number of errors. But financially, that same feature makes OpenClaw the most expensive agentic tool on the market when using Anthropic or OpenAI directly.

Comparing burn rate with other tools on the same task:

• Cursor Agent: ~5K—50K tokens per task
• Cline: ~500K—5M tokens per task
• Claude Code: ~200K—3M tokens per task
• OpenClaw: ~3M—50M tokens per task (×5—10 vs Cline)

OpenClaw supports any OpenAI-compatible providers via environment variables and a config file. This means that switching from the Anthropic API to JoinGonka Gateway does not require a single line of code changes in OpenClaw itself — just changing the endpoint and API key.

Comparison by task type:

OpenClaw's multi-level architecture, which makes it expensive at Anthropic, turns into an advantage at JoinGonka: more role-based calls = higher decision-making accuracy, and now it costs almost nothing. You can include all critics and reviewers, leave autonomous runs overnight, and experiment with long chains — without the fear of seeing a four-digit bill in the morning.

JoinGonka Gateway charges for input and output — fractions of a cent per million tokens (output is more expensive than input). At Anthropic, input costs $3, output — $15: even JoinGonka's output is hundreds of times cheaper, which is especially beneficial for OpenClaw, which generates many output tokens during role-based exchanges.

What's under the hood — the network's open MoE models: MiniMax M2.7 (the default model in the config below), DeepSeek V4 Flash, and GLM-5.3 Flash. For role-based tasks (planning, execution, criticism), structured output and tool calling are essential — all three models support native tool calling. On the SWE-bench Verified benchmark, which measures autonomous development quality, DeepSeek V4 Flash is neck-and-neck with closed-source flagships. Read more in the article about the best models for code. General market context — in the review of the cheapest AI API in 2026.

The easiest way is a one-command installer: it will configure the JoinGonka provider in ~/.openclaw/openclaw.json with the correct baseUrl and models, making a backup of your current config:

npx @joingonka/setup --tool openclaw

This is the universal JoinGonka installer — without the npx @joingonka/setup flag it will prompt you to pick a tool from a list (there are already 25: Claude Code, Codex CLI, OpenClaw, Cline and others — full list), ask for your API key (jg-…) and add only the JoinGonka provider without touching your other settings. The primary model will be DeepSeek V4 Flash, with GLM-5.3 Flash and MiniMax M2.7 as fallbacks: if a model is busy, the agent switches to the next one instead of stopping. Below is the manual path if you prefer to set it up yourself.

{
  "models": {
    "providers": {
      "gonka": {
        "baseUrl": "https://gate.joingonka.ai/v1",
        "api": "openai-completions",
        "apiKey": "jg-your-key",
        "models": [
          { "id": "deepseek-ai/DeepSeek-V4-Flash-0731", "name": "DeepSeek V4 Flash", "contextWindow": 380000, "maxTokens": 32768 },
          { "id": "zai-org/GLM-5.3-Flash", "name": "GLM-5.3 Flash", "contextWindow": 390000, "maxTokens": 8192 },
          { "id": "MiniMaxAI/MiniMax-M2.7", "name": "MiniMax M2.7", "contextWindow": 200000, "maxTokens": 8192 }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "gonka/deepseek-ai/DeepSeek-V4-Flash-0731",
        "fallbacks": ["gonka/zai-org/GLM-5.3-Flash", "gonka/MiniMaxAI/MiniMax-M2.7"]
      }
    }
  }
}

Let's compare three typical OpenClaw production usage profiles.

Profile 1: "Agent experiment". A developer runs OpenClaw 5—10 times a week, mostly on medium-sized tasks to assess quality. Monthly consumption — ~50M total tokens.

• Anthropic: 50M × $0.005 ≈ $250/month
• JoinGonka: 50M × $0.0099 = $0.50/month. Savings — ~500x.

Profile 2: "Regular use as part of a workflow". OpenClaw is run on complex tasks daily, sometimes left for long autonomous sessions. Monthly consumption — ~500M total tokens.

• Anthropic: 500M × $0.005 ≈ $2500/month
• JoinGonka: 500M × $0.0099 = $4.95/month. Savings — ~500x.

Profile 3: "Production-pipeline on OpenClaw". A team has automated part of their workflows via OpenClaw — report generation, refactoring legacy code, code review. Consumption — ~3B total tokens per month.

• Anthropic: 3B × $0.005 = $15000/month
• JoinGonka: 3B × $0.0099 = $29.7/month. Savings — ~500x.

At the Profile 3 level, the effect is particularly interesting — OpenClaw shifts from "too expensive for regular automation" to "so cheap that you can automate everything possible." This changes the very economics of decision-making: a task that previously seemed too expensive for an agent can now be handed off without a second thought.

On an annual horizon, an active user saves about $30,000, and a team saves $180,000. This is no longer just budget optimization; it is a qualitative change in how a team uses agentic AI: unlimited usage instead of "budget-constrained".

At the same time, OpenClaw itself as a tool remains unchanged: the same role-based pipelines, the same high-quality decomposition, the same control via critics. Only the source of inference changes — and with it, the economics of the entire workflow.

Strategy for mixing models in OpenClaw. OpenClaw supports different models for different roles in a pipeline. Through JoinGonka Gateway, you can assign MiniMax M2.7 for all stages (general-purpose model), or combine it with GLM-5.3 Flash for the critic and final check — the reasoning-model "thinks" before answering, which is especially useful when evaluating multi-step results — and for large prompts without reasoning, set DeepSeek V4 Flash (380K context). Since all three models are priced at $0.0069/1M, there is no financial bonus from using a "lighter" model in cheap roles — but you can fine-tune the quality of answers for each stage of the pipeline.

Production-case: code review automation. One of the real-world scenarios made possible by JoinGonka economics — automatic code review for every pull request via OpenClaw. Pipeline: "read diff → analyze every file → check test coverage → compile final report". On Anthropic, this pipeline would consume ~$5—15 per PR; on JoinGonka — $0.007—0.017. A team of 10 developers making 50 PRs a day goes from $750/day on Anthropic to $0.83/day on JoinGonka — and the code review agent turns from a luxury into a daily workflow.