TL;DR — An OpenClaw agent makes dozens to hundreds of LLM calls per day, and most of them don't need a frontier model. Three layers control what that costs and how fast it feels: routing (send each call to the cheapest capable model), caching (never pay twice for the same context), and orchestration (heartbeats, cron jobs, and sub-agents each pinned to the right tier). Current provider pricing spans a 500× range — from Gemini 3 Flash at $0.075/1M input tokens to Claude Opus at $15/1M — which is exactly why routing matters. Router overhead is negligible when done right: ClawRouters adds sub-10ms classification on top of model inference that typically runs 400ms–3s. Benchmark numbers below, plus a method to measure your own stack.
Why OpenClaw agents specifically need a routing layer
OpenClaw's architecture multiplies LLM calls in ways a simple chatbot doesn't:
- Heartbeats poll on a schedule and reason about whether anything needs doing — high frequency, usually low difficulty
- Memory operations summarize and index conversations — mid difficulty, batchable
- Main-session replies are what the user actually sees — quality-sensitive
- Sub-agents and cron tasks fan out background work — mixed difficulty, latency-tolerant
Pin everything to one frontier model and you pay Opus prices for heartbeat no-ops. Route by task type and the bill drops 60–90% with no visible quality change — the math is in our OpenClaw cost optimization guide.
LLM provider pricing (2026)
Current pay-as-you-go rates per million tokens:
| Provider | Model | Input /1M | Output /1M | |----------|-------|-----------|------------| | Anthropic | Claude Opus 4 | $15.00 | $75.00 | | Anthropic | Claude Sonnet 4 | $3.00 | $15.00 | | OpenAI | GPT-5.5 | $5.00 | $30.00 | | OpenAI | GPT-5.4 | $2.50 | $15.00 | | Google | Gemini 3 Pro | $1.25 | $5.00 | | Google | Gemini 3 Flash | $0.075 | $0.30 | | DeepSeek | DeepSeek V4 Pro | $1.74 | $3.48 | | DeepSeek | DeepSeek V4 Flash | $0.14 | $0.28 | | Moonshot | Kimi K2.6 | $0.60 | $4.00 | | Z.ai | GLM-5.1 | $1.40 | $4.40 |
The spread is the story: 200× between the cheapest and most expensive input token. A heartbeat that runs 48 times a day on Opus costs real money; on Gemini 3 Flash or DeepSeek V4 Flash it rounds to zero. Full breakdown in the 2026 AI pricing guide.
Caching: the second-biggest lever
OpenClaw agents resend large, mostly-identical context (system prompt, memory files, tool definitions) on every call. Two caching layers apply:
- Provider prompt caching — Anthropic, OpenAI, DeepSeek, and Zhipu all discount cached input heavily (typically 75–90% off). For agents with a stable system prompt, this alone can cut input spend by half or more. Structure prompts so the stable prefix comes first — cache hits require exact prefix matches.
- Router-level response caching — identical requests (repeated heartbeat checks, duplicate tool lookups) can be served from cache without touching the provider at all.
The practical rule: an OpenClaw agent whose system prompt and memory block sit at the front of the request pays cached rates for the bulk of its input tokens. Agents that interleave dynamic content early in the prompt break the cache every call.
Latency: what to actually expect
Honest framing first: model inference dominates latency, not routing. A router that classifies in single-digit milliseconds is invisible next to inference that takes 400ms–3s depending on model and output length. Our measured overheads (details in the low-latency router comparison):
- Routing classification: <10ms added per request
- End-to-end P95 for simple routed queries: under 200ms with fast-tier models
- Flash/mini-class models consistently deliver 2–5× faster time-to-first-token than frontier models — routing easy calls to them improves both cost and perceived speed
For heartbeat and background traffic, latency barely matters — which is exactly why those calls should go to the cheapest tier.
Benchmark it yourself (10-minute method)
Provider latency varies by region, time of day, and payload — so measure your own traffic instead of trusting anyone's table (ours included):
- Take 50 real prompts from your agent's logs — mix heartbeats, memory ops, and user replies
- Replay each against 3 candidate models, recording time-to-first-token and total time
- Compare cost per call from the pricing table above
- Route each call class to the cheapest model whose quality you accept — then verify with a week of production traffic
ClawRouters does steps 2–4 automatically: it classifies each request, routes to the cheapest capable model with automatic fallback, and shows per-request model attribution so you can audit every decision. The free tier is enough to benchmark a personal OpenClaw agent — see how much routing saves on a typical setup.