How to Model Your AI Agent's Real Cost: A Field Guide to the Agent Cost Calculator
What each input on the agent cost calculator means, how to estimate calls and tokens per call from a real job, and why the replay column reads $0.00 — with cited prices and a real receipt.
- 01The calculator asks for exactly three things — run interval, average tokens per run, and model price — and multiplies them. It has no fourth input on purpose.
- 02Load it at its defaults and it reads $12.96/month: an hourly agent, 18,000 tokens per run, Claude Haiku 4.5 at $1.00 per million input tokens. Every digit is arithmetic on a cited number.
- 03The replay column is $0.00 for one honest reason — Level-0 replay never constructs a model — and it covers the deterministic core of the job, not the judgment.
The agent cost calculator has no model behind it. It is three multiplications on numbers you supply, and the whole design goal is that you can audit every one of them. This field guide walks the three inputs, shows how to estimate each from a real job, and is honest about what it leaves out — a floor you can trust beats a forecast you can't.
1. The three inputs — and the ones it ignores on purpose
The tool has exactly three fields:
- Run interval — a dropdown: every 5 minutes, every 15 minutes, every hour, or every day.
- Avg tokens per run — a number, defaulting to 18,000.
- Model price — a dropdown of input-token list prices (Claude Haiku 4.5 at $1.00/MTok, Claude Sonnet 4.6 at $3.00/MTok, GPT-5.6 Sol at $5.00/MTok) plus a Custom $/MTok field for anything not listed.
From those it prints four numbers: runs/month, tokens/month, dollars burned per month on agent re-runs, and the replay column at $0.00.
What it does not ask for matters as much. There is no field for output tokens, retries, or prompt-cache state — deliberately. The calculator prices every token at the model's input rate, and input-rate-only understates a real bill: output tokens cost roughly 5–6× more on every model listed. So the figure it prints is a floor, not a prediction — your real bill is higher, but the floor is defensible line by line.
2. Estimating calls: read it straight off the schedule
Calls per month is the one factor with zero estimation error — it's your cron line, over a 30-day month:
| Interval | Runs/month |
|---|---|
| Every 5 minutes | 8,640 |
| Every 15 minutes | 2,880 |
| Every hour | 720 |
| Every day | 30 |
Notice the leverage: nothing about the work changed between the top row and the bottom, only the timer. A job set to every 5 minutes isn't 288× harder than a daily one — it's 288× more expensive for the same recipe. That's the whole thesis of the cost series pillar: on a schedule, the bill tracks the cadence, not the difficulty.
3. Estimating tokens per call — the number people get wrong
People assume tokens-per-run tracks how hard the task is. On a recurring job it mostly tracks the context the session drags along — instructions, tool definitions, prior results, transcript. That's why the default is 18,000 and not 200.
That 18,000 is measured, not guessed. It's the average from Reelier's published benchmark: a real npm-registry agent workflow, run ten times, averaging 18,390 input + 136 output tokens per run at about $0.019 per run.
To size your job, don't guess a round number — read a real run. If your agent already did the task once, its run record has the actual input-token count. A tiny two-step lookup lands near 18k; a heartbeat carrying full session context sits closer to 120k. Same axis, very different bills — the only way to know is to read one run.
4. The worked example, with cited prices
The formula, in full:
$/month = (runs/month × tokens/run) ÷ 1,000,000 × $/MTok
Load the calculator at its defaults — hourly, 18,000 tokens, Claude Haiku 4.5 — and it computes:
- runs/month = 720
- tokens/month = 720 × 18,000 = 12,960,000
- $/month = 12,960,000 ÷ 1,000,000 × $1.00 = $12.96
That $1.00/MTok input price for Claude Haiku 4.5 is from the Anthropic pricing page (retrieved 2026-07-21). Tighten the schedule to every 15 minutes and only the first factor moves: 2,880 × 18,000 = 51,840,000 tokens → $51.84/month on the same Haiku rate. Swap the model to GPT-5.6 Sol at $5.00/MTok (from the OpenAI pricing page, retrieved 2026-07-21) and the same 51.84M tokens become $259.20/month.
None of those totals are typed in — each is the formula applied to a cited input, the discipline the tool enforces. Prices move, though: if a listed rate looks stale, the Custom field takes the current number straight off the vendor page.
5. What the $0.00 replay column actually claims
The replay column is not a discount or a projection. A Reelier skill is a run that worked, compiled to a file; at Level 0 — the default — the replay re-executes the recorded tool calls and checks their assertions, and no LLM client is ever constructed. Zero tokens by construction, verified from each run's record (llmInputTokens === 0) — that's what Level-0 replay means by "zero-token."
Three boundaries the calculator's asterisk is honest about, and so is this post:
- It's the deterministic core only. Fetch-extract-assert steps replay for free; triage, synthesis, and prose still need a model every run. Model help during replay is opt-in and laddered (BYOK), and a destructive step is never auto-escalated.
- It's read-only by default. A write step doesn't re-fire on replay unless you pass
--allow-writes; a destructive one needs an explicit--yes. - It's not a cache. A warm prompt cache makes the same expensive call cheaper; replay removes the call. That distinction — and why it survives a model swap that busts a cache — is the whole of Reelier vs. behavior caches.
And because the compiler writes minimal assertions — only steps with a clean recorded result get one; failed or result-less steps stay assertion-less and replay as unchecked, never silently "passed" — the receipt tells you exactly which steps it actually verified.
Here's that receipt, verbatim from the project README:
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.
6. Run your own numbers
Plug your schedule, your measured tokens-per-run, and today's price into the agent cost calculator — it prints your floor next to the $0.00 replay column, and the URL carries your inputs so the result is a shareable link.
If your job has a shape, the priced-out companions go deeper: OpenClaw heartbeat costs for the 120k-token idle check, scheduled agents at zero tokens for cron-first setups, heartbeat economics for the cadence math, and model-upgrade regression for what a version bump does to the bill. Measure one run, price the floor, then decide which half of the job needs the model.