---
title: "Cursor Background Agents on a Schedule: The Per-Run Token Bill Nobody Budgets For"
description: Cursor's $20 Pro plan hides the real cost of a scheduled background agent — usage billed in arrears at model API rates. The formula, the caveats, and how to replay the deterministic half at 0 tokens.
date: 2026-07-21
slug: cursor-background-agent-costs
author: Maxime Houle
tags: cursor, background-agents, costs, reelier
kicker: Cost engineering
---

```short-version
- Cursor's $20 Pro plan includes a set amount of model usage, then bills overage in arrears at model API rates — a scheduled background agent is the thing most likely to blow through the included amount.
- The bill is runs/month × (input tokens × input rate + output tokens × output rate), all rates published on Cursor's pricing docs.
- Record the deterministic tool-call core once and replay it at 0 tokens. For Cursor there's no history scan — capture is the wrap proxy only.
```

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.

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

Cursor moved to usage-based billing, and the [pricing page](https://cursor.com/pricing) (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."

```source
url: https://cursor.com/pricing
meta: Cursor pricing · retrieved 2026-07-21
link: See Cursor pricing
> "On-demand usage allows you to continue using models after your included amount is consumed, billed in arrears."
```

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.

## 2. 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](https://cursor.com/docs/account/pricing) (retrieved 2026-07-21), per million tokens:

| Model (Cursor API pool) | Input /MTok | Output /MTok |
|---|---:|---:|
| Composer 2.5 (Cursor's own) | $0.50 | $2.50 |
| Claude Sonnet 5 | $3.00 ($2.00 promo through 2026-08-31) | $15.00 |
| Claude 4.5 Haiku | $1.00 | $5.00 |

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](https://github.com/seldonframe/reelier/blob/main/docs/strategy/reelier-launch/benchmark-results.md), 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):

| Model | Cost/run (formula) | Every 4h · 180/mo | Hourly · 720/mo | Every 15 min · 2,880/mo |
|---|---:|---:|---:|---:|
| Composer 2.5 | $0.0095 | $1.72 | $6.87 | $27.46 |
| Sonnet 5 (promo $2 in) | $0.0388 | $6.99 | $27.95 | $111.80 |
| ✓ Reelier replay · Level 0 | $0.0000 | $0 | $0 | $0 |

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.

```figure
diagram: cost-over-runs
caption: The same scheduled background agent, re-run every time vs. replayed
```

## 3. 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](/learn/tool-call-drift). Replay the re-derivation for free; wake the model only when a step changes.

## 4. 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](/learn/mcp-recording)):

```sh
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:

```sh
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](/learn/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](/blog/model-upgrade-regression).

## 5. 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 wrap proxy records live rather than reconstructing a transcript — like a VCR cassette for your tool calls ([Reelier vs. VCR](/vs/reelier-vs-vcr)). The same record-once, replay-forever shape fits any IDE with no scannable history — see the [Windsurf workflow cost](/blog/windsurf-workflow-costs) sibling and the [agent token-costs pillar](/blog/agent-token-costs-pillar).

## 6. 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](/tools/agent-cost-calculator) and read the re-run bill next to the replay column pinned at $0.