Cursor Background Agents on a Schedule: The Per-Run Token Bill Nobody Budgets For

A Cursor background agent on a schedule — Composer looping hourly to check tests, pull metrics, or summarize a feed — feels free, because the $20/month Pro line already cleared your card. It isn't. Cursor's pricing is usage-based: your plan includes a set amount of model usage, everything past it billed in arrears at model API rates. A job on a timer spends past that line while nobody's watching.

This post derives the bill from Cursor's published rates, marks the one number you supply, and runs the deterministic half at 0 tokens.

011. The bill Cursor doesn't put on the pricing page

Cursor moved to usage-based billing, and the pricing page (retrieved 2026-07-21) states the mechanism plainly: every plan includes a set amount of model usage, and on-demand usage continues after it, billed in arrears. Pro is $20/month and comes with an included model-usage allowance; Cursor documents the arrears mechanism but doesn't publish the allowance as a dollar figure, so this post never pins a run count to a specific "$20 line."

Interactive, that's fine — you're at the keyboard watching the meter. A background agent inverts it: unattended, on a cadence you set for freshness, draining the same monthly allowance whether or not it did anything.

022. The formula, with Cursor's own rates

The bill is arithmetic:

runs per month × (input tokens × input rate + output tokens × output rate).

Runs per month is just the schedule. Input and output rates are published on Cursor's model pricing docs (retrieved 2026-07-21), per million tokens:

The one factor you supply is tokens per run — it tracks the context your agent drags along, not the task's difficulty. There's no published Cursor figure, so as a cited anchor I'll use the Reelier benchmark, where a small two-step task measured 18,390 input / 136 output tokens per run. A real background agent reading repo files carries far more — treat this as a floor.

At that anchor, the formula gives (per-run figures rounded):

Two honest notes. First, these totals are the formula at a cited small-task token count — a worked example, not a measured Cursor invoice; your context sets your real number. Second, mind the arrears: once a schedule's monthly total exhausts your plan's included allowance, every further run bills on-demand at the rates above — even Composer 2.5 reaches $27.46/mo at a 15-minute cadence, and Sonnet 5 reaches $27.95 running merely hourly. After 2026-08-31 Sonnet 5's input rate returns to $3.00/MTok, lifting its column by half again.

033. Which half of a background agent is actually judgment

The fix touches only one side of the job. Judgment work — writing code for a new change, triaging an unfamiliar failure, composing prose — needs a model every run; if your background agent does open-ended editing, replay is the wrong tool and this post isn't your fix.

Re-derivation is the rest, and scheduled agents are thick with it: run the tests and check the exit code, pull the same three metrics, diff a feed, post a summary. Your agent worked that tool-call sequence out correctly once; re-deriving it every run just risks tool-call drift. Replay the re-derivation for free; wake the model only when a step changes.

044. Record once, replay on the schedule

The loop is record → compile → replay → diff, all local, no API key.

Recording on Cursor has exactly one path, and it matters. Cursor stores its session history in a SQLite database, not a replayable tool-call transcript, so Reelier has no history scan for Cursor — unlike Claude Code, reelier scan cannot read a Cursor session. Capture is the wrap proxy only: a lossless recorder that fronts your MCP server while the agent runs the job once as usual (this is MCP recording):

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

That compiles the trace into a SKILL.md with minimal assertions — only steps whose recorded result was clean get an assertion; a step that failed or returned nothing stays assertion-less and replays as unchecked, surfaced as an open question, never silently marked passed.

Then replace the scheduled LLM run with a replay:

npx -y reelier run <job>.skill.md   # Level 0: no model constructed, 0 tokens
npx -y reelier diff <job>           # SAME or DRIFTED per step — exit 1 on drift

Level-0 replay never constructs a model client, so the deterministic core costs 0 tokens by construction — scoped to that core; judgment still needs a model, opt-in BYOK. It's read-only by default: an idempotent-write step re-fires only with --allow-writes, a destructive step needs an explicit --yes, so a scheduled replay can't quietly re-send or re-create anything. The nonzero exit on drift is your wake signal: quiet runs cost nothing, the run where the API shifted gets attention. Swapping the model behind a Cursor agent is a classic drift trigger too — see model-upgrade regression.

055. A real receipt

Reelier's install demo closes with this, reproduced 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.

The wrap proxy records live rather than reconstructing a transcript — like a VCR cassette for your tool calls (Reelier vs. VCR). The same record-once, replay-forever shape fits any IDE with no scannable history — see the Windsurf workflow cost sibling and the agent token-costs pillar.

066. Run your own numbers

The table above is the formula at a small cited task. Your agent carries your context, schedule, and model — plug all three into the agent cost calculator and read the re-run bill next to the replay column pinned at $0.