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

OpenClaw is an autonomous agent with a multi-layered architecture. Unlike simple assistants, where one prompt goes to the model and returns a response, OpenClaw builds a chain of several roles and several iterations. Each link in the chain consumes tokens, and the total consumption for a single user task exceeds that of a chat assistant by an order of magnitude or more.

Typical OpenClaw workflow for the task "write module X":

1. Planner reads the task description and the entire project context (~30K input + 2K output)
2. Decomposer breaks 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 checks results and suggests corrections (~40K input + 2K output)
5. Corrector applies fixes (5-10 iterations × ~30K input + 2K output)
6. Final verification and report generation (~30K input + 1.5K output)

Add it all up — for an average task, OpenClaw consumes 800K-1.5M input tokens and 50-120K output tokens. For complex tasks with long autonomous iterations, consumption grows to 5-15M input + 200-500K output.

Real figures for specific types of tasks:

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

The main difference from Cline or Cursor is that OpenClaw makes 3-5 role calls at each step, whereas Cline makes one. This is not a bug — it's a feature that improves decision-making quality and reduces errors. But financially, it also makes OpenClaw the most expensive agentic tool on the market when using Anthropic or OpenAI directly.

Comparison of consumption speed with other tools for 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 of Cline)

OpenClaw supports any OpenAI-compatible providers via environment variables and a config file. This means that switching from Anthropic API to JoinGonka Gateway requires no changes to the OpenClaw code itself — only changing the endpoint and API key.

Comparison by task types:

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

JoinGonka Gateway charges input and output equally — at $0.001/1M. On Anthropic, input costs $3, output — $15. This means that OpenClaw, which generates a lot of intermediate output tokens during role exchanges, saves even more compared to native Claude Sonnet 4.5.

What's under the hood — the Qwen3-235B-A22B-Instruct model (MoE with 22B active parameters). For role-based tasks (planning, execution, criticism), its capabilities for structured output and tool calling are significant: the model supports native tool calling via PR #767 with a threshold of 0.958. On the SWE-bench benchmark, which measures the quality of autonomous development, Qwen3-235B performs at the level of Claude Sonnet 4.5. More details in the article about Qwen3-235B. The overall market context is in the review of the cheapest AI API in 2026.

OpenClaw reads configuration from environment variables and from a local config file (default ~/.openclaw/config.yaml). To switch to JoinGonka, you just need to change two values — base URL and API key.

Step 1. Get a JoinGonka API key. Register at gate.joingonka.ai/register, get 10M free tokens for testing, copy the key from the Dashboard (format jg-xxx).

Step 2a. Method via environment variables. The fastest way:

export OPENAI_BASE_URL=https://gate.joingonka.ai/v1
export OPENAI_API_KEY=jg-your-key
export OPENCLAW_MODEL=Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
openclaw run "task"

To save variables — add them to ~/.bashrc or ~/.zshrc.

Step 2b. Method via config file. More reliable for production. Open ~/.openclaw/config.yaml and add:

provider: openai
base_url: https://gate.joingonka.ai/v1
api_key: jg-your-key
model: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8
max_tokens: 2048
temperature: 0.3

This config is loaded automatically every time OpenClaw runs.

Step 3. If using multiple role agents. OpenClaw allows assigning different models to different roles — for example, a lighter model for the planner and a more powerful one for the executor. Through JoinGonka, you can use the same Qwen3-235B for all roles (it's strong enough for the entire pipeline) or combine it with other network models, such as Kimi K2.6 (if you need a long context window for the critic). Details — in the article about Kimi K2.6.

Step 4. Limits and protection. OpenClaw can limit the maximum number of iterations and the maximum token consumption per task. Even on JoinGonka, it's worth setting reasonable limits (e.g., 1M tokens per task) — this protects against accidental loops and speeds up debugging the agent's logic itself. In config:

limits:
  max_iterations: 50
  max_tokens_per_task: 1000000
  max_cost_per_task_usd: 1.00

Step 5. Verification. Run a simple task — openclaw run "create a hello world function in python". If the agent has gone through the planning, execution, and verification cycle and produced the final file, the setup is complete. Consumption in the JoinGonka Dashboard will appear in real time.

The same JoinGonka key works with other agentic tools: Cline, Cursor, Claude Code. All of them are billed from the overall account balance.

Let's compare three typical OpenClaw usage profiles in production.

Profile 1: "Experimenting with agents." A developer runs OpenClaw 5-10 times a week, mainly on medium tasks to assess quality. Monthly consumption — ~50M total tokens.

• Anthropic: 50M × $0.005 ≈ $250/month
• JoinGonka: 50M × $0.001 = $0.05/month. Savings — 5000 times.

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

• Anthropic: 500M × $0.005 ≈ $2500/month
• JoinGonka: 500M × $0.001 = $0.50/month. Savings — 5000 times.

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

• Anthropic: 3B × $0.005 = $15000/month
• JoinGonka: 3B × $0.001 = $3/month. Savings — 5000 times.

At Profile 3's level, the effect is particularly interesting — OpenClaw transforms from "too expensive for regular automation" to "so cheap you can automate everything imaginable." This changes the very economics of decision-making: a task that once seemed too expensive for an agent can now be handed to it without hesitation.

Over a year, an active user saves about $30000, and a team saves $180000. This is no longer just budget optimization; it's a qualitative change in how a team uses agentic AI: free instead of "within budget."

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

Strategy for mixing models in OpenClaw. OpenClaw supports different models for different roles in the pipeline. Through JoinGonka Gateway, you can assign Qwen3-235B for all stages (a universal strong model), or combine it with Kimi K2.6 for the critic and final review — Kimi has a long context and strong reasoning, which is especially useful for evaluating multi-step results. Since both models are priced at $0.001/1M, there's no financial bonus from using a "lighter" model for cheaper roles — but you can fine-tune the quality of responses for each pipeline stage.

Production case: automating code review. One of the real scenarios made possible by JoinGonka's economics is automated code review for each pull request via OpenClaw. Pipeline: "read diff → analyze each file → check test coverage → generate final report." On Anthropic, this pipeline would cost ~$5-15 per PR; on JoinGonka — $0.002-0.005. A team of 10 developers making 50 PRs a day goes from $750/day on Anthropic to $0.25/day on JoinGonka — and the code review agent transforms from a luxury into an everyday workflow.