---
title: Your OpenClaw cron burns 2,880 LLM calls a month. Here's the same job at zero.
description: The documented cost of OpenClaw heartbeats, the first-principles math behind the bill, and how to replay the deterministic half of the job at 0 tokens.
date: 2026-07-21
slug: openclaw-cron-costs
author: Maxime Houle
tags: openclaw, cron, costs, reelier
kicker: Cost engineering
---

```short-version
- OpenClaw fires a full LLM call on every heartbeat: up to 2,880 a month at a 15-minute cadence.
- On Opus 4.8 that bill runs $1,728 a month to hear "nothing to do."
- Record the deterministic check once, replay it at 0 tokens, and wake the model only when a step drifts.
```

OpenClaw's heartbeat is a good idea with an expensive implementation: on a timer, the agent wakes up and asks the model whether anything needs doing. Every one of those wake-ups is a full LLM call, and it carries the session's context with it. If the answer is "no, nothing needs doing" — which for a healthy system is almost every time — you paid full price to hear it.

This post does three things: shows the bill is documented (not a strawman), derives it from first principles so you can plug in your own numbers, and walks through running the same job at 0 tokens — with a real receipt at the end, not a projection.

## The bill is documented

This isn't a hypothetical. [NotebookCheck covered it in February 2026](https://www.notebookcheck.net/Free-to-use-AI-tool-can-burn-through-hundreds-of-Dollars-per-day-OpenClaw-has-absurdly-high-token-use.1219925.0.html): heartbeat checks sending roughly 120,000 tokens of context per request, at about $0.75 a request. One user's agent made about 25 requests overnight — effectively paying Claude Opus to answer "is it daytime yet?" — and woke up $18.75 poorer. The German magazine c't spent over $100 in a single day of testing. The article projects idle heartbeat costs alone at around $250 a week.

The root cause is structural, not a bug: the Messages API is stateless, so each request re-sends the conversation history, and a long-lived agent session accumulates a lot of it. A trivial "any tasks pending?" check pays for the whole context.

OpenClaw's own documentation treats this as a fact of life to be managed. The [official token-use page](https://docs.openclaw.ai/reference/token-use) is essentially a list of mitigations: trim large tool outputs, shrink screenshots, keep skill descriptions short, run `/compact` on long sessions, and set the heartbeat interval just under your model's cache TTL so the cache stays warm. The [heartbeat docs](https://docs.openclaw.ai/gateway/heartbeat) put the default interval at every 30 minutes (60 for OAuth-authenticated setups), configurable per agent.

Mitigations are fine. But they all optimize a number that, for the deterministic part of the job, could be zero.

```source
url: https://insiderllm.com/guides/openclaw-token-optimization/
meta: operator audit · May 2026
link: Read the audit
> "If you're running Opus as your primary model, heartbeats alone can cost $5/day. That's $150/month to do nothing."
```

## The math, from first principles

The formula is short: **calls per month × tokens per call × price per token.**

Calls per month is just the schedule:

| Schedule | Calls/day | Calls/month (30d) |
|---|---:|---:|
| Every 30 min (OpenClaw default heartbeat) | 48 | 1,440 |
| Every 15 min (a typical cron check) | 96 | **2,880** |

Tokens per call: we'll use the 120,000-token context documented in the NotebookCheck report above. Your session may carry less; long-lived agent sessions often carry more.

Price per token, from the [Anthropic pricing page](https://platform.claude.com/docs/en/about-claude/pricing) (retrieved 2026-07-21): Claude Opus 4.8 at $5.00 per million input tokens, Claude Sonnet 5 at $3.00, Claude Haiku 4.5 at $1.00. Input side only — output tokens ($25 / $15 / $5 per million respectively) are on top, though for a short "nothing to do" reply they're a rounding error.

Putting it together, at 120k input tokens per call:

| Model tier | Cost/call (input) | Monthly, every 30 min | Monthly, every 15 min |
|---|---:|---:|---:|
| Opus 4.8 ($5.00/MTok) | $0.60 | $864 | $1,728 |
| Sonnet 5 ($3.00/MTok) | $0.36 | $518 | $1,037 |
| Haiku 4.5 ($1.00/MTok) | $0.12 | $173 | $346 |
| ✓ Reelier replay · Level 0 | $0.00 | $0 | $0 |

Two honest footnotes. First, Sonnet 5 has an introductory price of $2.00/MTok through 2026-08-31 (same source), which shaves the middle row by a third — temporarily. Second, switching providers doesn't change the shape: OpenAI's flagship GPT-5.6-Sol is also [$5.00 per million input tokens](https://developers.openai.com/api/docs/pricing) (retrieved 2026-07-21).

The biggest honest footnote is prompt caching. Anthropic's [caching docs](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) price cache reads at roughly 0.1× the base input rate, so a fully warm 120k-token context on Opus costs about $0.06 per call instead of $0.60 — call it $86–$173 a month on the schedules above, plus cache-write premiums (1.25× for the 5-minute TTL, 2× for the 1-hour TTL). That's a real 10× improvement, and it's exactly why the OpenClaw docs tell you to tune the heartbeat interval against the cache TTL. But notice what you're doing at that point: scheduling your infrastructure around a cache expiry window to make a recurring bill smaller. The optimized number is still not zero, and it's one config drift away from being 10× again.

```figure
diagram: cost-over-runs
caption: Cumulative cost over one month of heartbeats
```

## Which half of the job is actually judgment?

Here's the split that matters, and it's worth being precise about because the fix only applies to one side of it.

**Judgment work** needs a model every time: deciding what to do about an anomaly, writing prose for a human, triaging something genuinely new, figuring out a workflow for the first time. If your cron job's inputs are open-ended and the right response changes run to run, that's LLM work. Keep paying for it — it's what the model is for.

**Re-derivation** is everything else: the same sequence of tool calls, with the same shape, producing the same kind of answer, every single time. Status checks. Data pulls. Report generation. CRUD sequences. The heartbeat's actual mechanics — call these three endpoints, check these fields, report pass or fail — is a recipe your agent already derived correctly once. Every subsequent run pays the model to re-derive it, with some probability of deriving it slightly differently. That's the drift problem wearing the cost problem's clothes.

Most cron jobs are a thin layer of judgment on top of a thick layer of re-derivation: "check if anything needs attention" is deterministic checking plus conditional attention. The economical shape is to replay the check for free and wake the model only when the check fails.

To be equally honest about the boundary: [Reelier](https://github.com/seldonframe/reelier) replays tool calls — typed JSON in, typed JSON out. It cannot replay open-ended coding sessions, file-editing work, or anything whose steps legitimately differ each run. If your job is all judgment, this post isn't your fix.

```source
url: https://riskspan.com/i-was-the-cron-job-what-a-1990s-back-office-taught-me-about-ai-token-costs/
meta: "I Was the Cron Job" · Jul 2026
link: Read the essay
> "Even against the fully optimized agent, the deployed script is one hundred to a thousand times cheaper."
```

## The fix: record once, replay on the heartbeat

Three steps, all local, no API key.

**1. Record the run that worked.** If the job already ran in a session, you don't need to run it again:

```sh
npx -y reelier scan          # finds replayable tool-call sequences in your agent history
```

Or record live by putting a lossless proxy in front of your agent's tools:

```sh
npx -y reelier mcp --wrap "<your mcp server command>"
```

Either path compiles the trace into a `SKILL.md` file — a recipe with an assertion on every step, checked into your repo like any other file.

**2. Replay it on the schedule.** Replace the LLM heartbeat call with:

```sh
npx -y reelier run <job>.skill.md
```

Level-0 replay never calls a model — 0 tokens by construction, not by optimization. It re-executes the recorded tool calls and checks every step's assertion. It's read-only by default: a write step never re-fires unless you explicitly pass `--allow-writes`, so a replay can't accidentally re-send an email or re-create a record.

**3. Diff for drift.** This is where the judgment boundary earns its keep:

```sh
npx -y reelier diff <job>    # SAME or DRIFTED, per step — exit 1 on drift
```

Exit 1 means the API shifted, the data shape changed, or an assertion failed — the moment that actually deserves a model (or a human). Wire the nonzero exit to wake your agent. The 2,879 runs where nothing changed cost nothing; the one run where something did gets full attention.

## A real receipt

Reelier's install demo closes with this — reproduced verbatim from the [project README](https://github.com/seldonframe/reelier):

```receipt
Your receipt:
  skill:        reelier-init-demo
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  44ms  [measured]
  LLM tokens:   0     [measured]

  An agent doing a comparable task re-reasons every run (~2.8s, ~18k tokens on
  our benchmark). Your replay: 44ms, 0 tokens.
```

The published head-to-head benchmark — agent vs. replay, same task, same live data, full method and tables in [`examples/benchmark`](https://github.com/seldonframe/reelier/tree/main/examples/benchmark) — measured:

- **1,000 / 1,000 replays byte-identical** (N=1000 tail-variance test)
- **0 tokens per replay** — verified from the run record, not assumed
- **~50× cheaper** ($0.000000/replay vs. $0.019068/run averaged over the agent arm)
- **~59× faster** (48ms vs. 2,842ms average latency)
- one real drift **self-healed for ~$0.001**, once — then free on every replay after

One caveat the benchmark itself states: replay latency varies with your network, because Level-0 replay re-executes the skill's real tool calls. What doesn't vary: 0 LLM tokens, the same steps every run, and a receipt for each one. The pattern is independently corroborated — [arXiv 2605.14237](https://arxiv.org/abs/2605.14237) found 93.3–99.98% token reduction for the same record-and-replay approach.

## Run your own numbers

Plug your schedule, context size, and model into the [agent cost calculator](/tools/agent-cost-calculator) — the table above at your numbers, next to the replay column.

If the job you're thinking of is a scheduled agent rather than a heartbeat specifically, the companion post — [scheduled agents at zero tokens](/blog/scheduled-agents-zero-token) — walks the cron-first version of this setup.

And if you run OpenClaw: the loop needs nothing but npx — no install step, no API key, no config beyond the skill file you already committed:

```sh
npx -y reelier run <job>.skill.md && npx -y reelier diff <job>
```

Record the job once. Replay it on the heartbeat. Pay for judgment, not re-derivation.