Before you leave an agent running: know which of four ceilings you’re under

A $1,400/hour Cursor bill and a $607 Replit surprise have the same root cause: the buyer didn’t know their plan’s ceiling type. Here’s the four-archetype check to run before any unattended session.

Every coding plan puts an unattended agent under exactly one of four ceilings: a quota wall, a block-or-overage meter, a bill-sensitive credit burn, or raw pay-per-token. Only the first caps your worst-case bill at $0 extra by default — and it’s the one developers complain about most. The $1,400-in-one-hour Cursor bill and the $607 Replit surprise both happened under the third ceiling, to buyers who thought they were under the first.

The live index already applies this classification to every plan it tracks; what follows is that classification walked plan by plan — the incident record behind each archetype, and the one guardrail each ceiling actually offers.

The four ceilings, in one table

The question that sorts every plan is: when the included allowance runs out mid-session, what happens next? The four possible answers are the four archetypes.

Ceiling	What stops the agent	Worst-case bill (default settings)	Plans under it
Quota wall	The vendor stops serving you until the window resets	$0 extra — the subscription price is the ceiling	Claude Pro/Max, Codex on ChatGPT plans
Block-or-overage	A budget policy: block at zero, or bill on	Whatever budget is configured — open-ended if none	GitHub Copilot
Bill-sensitive	Nothing, by default	Open-ended	Cursor, Replit, Devin
Pay-per-token	Nothing — every token bills at list price	Open-ended, but transparently priced	Direct API (e.g. Claude API)

The ceiling developers hate is the only safe one

A quota wall stops serving you instead of billing you — which is why it’s the only archetype whose worst case is measured in hours lost, not dollars owed. Claude Max 20× and Codex ChatGPT Pro 20×, both $200/mo, are flat-rate walls that carry no runaway-risk record in the index’s dataset — while the metered plans at that same $200 tier, Cursor Ultra and Devin Max, each carry one. Same price, opposite worst case; absence is the low-risk signal by design. The index even models the wall as a time bound, not a dollar bound: its usage projection computes the active hours into the week at which a binding weekly cap exhausts.

The complaints are real. Five-hour windows and weekly caps interrupt heavy agent work, and Anthropic doubled Claude Code’s 5-hour limits in May 2026 precisely because users kept hitting them. But hitting a wall costs you a wait. Hitting a meter costs you money.

One asterisk, and it matters: the wall is only a wall in its default, unmodified state. Claude Pro/Max offers optional usage credits that let you continue past quota at standard API rates — opt in, and your wall quietly becomes a meter. Codex has the same trapdoor: API-key mode is separate direct token billing that sits outside the ChatGPT-plan window entirely. Before an unattended run, confirm neither is active.

Bill-sensitive: where the incident reports live

The bill-sensitive archetype — Cursor, Replit, Devin — keeps working after the included allowance is gone and keeps charging, with no hard stop unless you built one. Every headline runaway-bill incident in the index’s evidence base sits here.

Cursor. A runaway agent session billed $1,400 in one hour — 87 tasks, roughly $16 per task, about $23 per minute — with no spend cap in the way; the CEO issued a manual refund. A forum thread from June 13, 2026 documents a single session reaching $600+. The index classifies every Cursor tier as bill-sensitive, high risk: the $20/mo Pro plan includes $20 of API usage, Ultra at $200/mo includes $400 — after that, the ceiling is your card. Cursor does document overage as visible and cappable, which is the guardrail to set.
Replit. Effort-based pricing bills for the agent’s thinking and rollbacks — even Plan Mode with no code changes can bill. One developer found a $607 charge after an unmonitored ~5-hour Agent session: once the monthly credits ran out, Replit kept charging at overage rates with “no hard stop, no popup.” Community reports peg active use at roughly $50/hour.
Devin. The index rates Devin elevated, not high — the evidence is reviews rather than incident reports. The risk is opacity: ACU pricing charges for thinking and rollbacks, and self-serve billing mixes daily/weekly ACU quotas with pay-as-you-go credits. An independent test gave Devin 10 real tasks; it completed 3 while consuming metered spend on all of them.

Cursor deserves one more line, because it runs two meters. Beyond the headline API pool, the Auto/Composer pool carries its own internal token prices — $1.25/M input, $6/M output at the index’s current dataset — against an unpublished included quantity. A second, less visible meter under the first.

Block-or-overage: Copilot’s ceiling is a setting

Copilot is its own archetype because exhaustion doesn’t have one outcome — a budget policy decides whether the agent stops or bills on. Since the June 1, 2026 move to usage-based billing, AI Credits (1 credit = $0.01) meter chat, CLI, agent, and premium-model work, while completions stay unlimited. Copilot Max at $100/mo includes 20,000 credits — $200 nominal. The transition was rough: TechCrunch reported bill spikes of roughly 10×–60× after the shift, with no opt-out. And because each model has its own credit rate, identical work costs different amounts depending on which model handled it. The guardrail is explicit: set the budget. At $0 it behaves like a quota wall; unset, it behaves like Cursor.

Pay-per-token: honest and unbounded

Direct API billing is the most transparent ceiling and the least protective. There is no included pool — the bill scales linearly with tokens at published per-token rates. Nothing surprises you about the price; what surprises you is the volume an unattended loop can generate. A runaway session bills at list price until you kill it or a workspace spend limit trips. If you run agents on raw API keys, the spend limit is not optional hygiene — it is the ceiling.

The pre-flight check

Before any unattended session, answer three questions. They take two minutes and would have prevented every incident cited above.

Name your ceiling. Find your plan in the table above. If your plan sells “credits,” “ACUs,” or “included usage” in dollars, you are bill-sensitive or block-or-overage — not quota-walled — no matter how flat the monthly price looks.
Compute your worst case. Quota wall: $0 extra, provided usage credits and API-key mode are off. Block-or-overage: your configured budget. Bill-sensitive and pay-per-token: open-ended until a cap you set yourself.
Set the one guardrail your archetype offers. Wall: verify the overflow opt-ins are disabled. Copilot: set a budget, even if it’s $0. Cursor: cap overage in billing settings. Replit/Devin: set usage alerts and treat the included allowance as the session budget. Raw API: set the workspace spend limit before the session, not after the invoice.

The pattern across every receipt in this piece is the same: the bill wasn’t a pricing scandal, it was an archetype mismatch. The developer ran a wall-shaped workflow on a meter-shaped plan. Know which ceiling you’re under before the agent starts — the plans that interrupt you are the ones that can’t surprise you.

Compare subscription ceilings against raw API metering →