Cursor usage limits explained

Cursor doesn't publish one clean number for how much you can use it. It runs on a monthly credit pool that shrinks with every agent request, plus a separate rate limit that can throttle you even when the pool still has money in it. If an agent run has ever stopped mid-task with a usage warning, or a prompt has cost far more than the one before it, this is why. Here's how Cursor's usage limits actually work as of September 2026, what changed when Cursor retired its flat Auto rate, and where a flat-rate lane like NeverMetered fits for the work that doesn't need a frontier model.

How Cursor's usage limits work

Cursor splits usage into two pools, both tied to your monthly billing cycle. One pool covers Cursor's own models, currently its Grok-based Cursor models and Composer 2.5. The other covers third-party models like Claude and GPT, billed at each provider's own rate. The free Hobby plan only gets the first pool. Pro, Pro+, and Ultra get both. Either way, unused usage does not roll over, so a light month buys you nothing extra the next one.

• Your pool balance, which resets monthly and never carries over
• Whether on-demand (pay-as-you-go) billing is switched on once that balance hits zero
• Cursor's short-term rate limit, which can throttle a burst of heavy agent runs independent of your remaining balance

When a pool runs dry, Cursor shows a notification in the editor: turn on on-demand billing to keep going at full API rates, or wait for the reset. On-demand is opt-in, but once it's on there's no default spend cap, so a busy month can cost a lot more than the plan price suggests. The rate limit is a different animal. It exists to protect Cursor's backend from bursts, so firing off several heavy agent runs back to back can get you briefly throttled even with plenty of pool remaining.

What the Auto pricing change did to your budget

Cursor's default Auto mode used to bill at one flat rate regardless of which model it picked behind the scenes. That ended on August 24, 2026. Auto now bills at whatever the routed model actually costs, and the spread is wide: Composer 2.5 sits at the cheap end, while a request Auto happens to route to a model like Claude Fable 5 can cost roughly eight times what the same-looking prompt cost the week before the change. That's not technically a usage limit, but it behaves like one. Your pool drains faster on the days Auto picks an expensive model, and there's no way to know ahead of time which requests will be cheap.

Cursor plans and what they include

Cursor's own pricing page describes the $20 Pro price as a starting point rather than a hard ceiling: on-demand usage above the included allowance bills automatically once you turn it on. Teams and Enterprise seats that bring their own API keys also pay a small per-token Cursor rate on top of the model's own price. If a Cursor seat is already part of the workflow and the goal is adding a flat-rate lane alongside it rather than replacing it, the Cursor integration guide covers pointing Cursor at an OpenAI-compatible endpoint outside Cursor's own billing.

Where the meter actually bites

In practice the pool empties fastest on runs that don't need a frontier model at all: a long refactor across a dozen files, a test suite getting iterated on for an hour, an agent chasing a flaky CI failure. None of that requires the same model reserved for a genuinely hard problem, but Cursor's pool doesn't distinguish a five-minute favor from a five-hour grind. Anyone who's run into the same shape of problem with Claude's usage limits or Codex's usage limits will recognize the pattern: one meter covering both routine and hard work tends to run out at the worst possible time.

A flat-rate lane for the routine work

NeverMetered runs on a different shape. Instead of a monthly credit pool, pricing is based on parallel streams, meaning how many requests can generate at the same time. There's no token meter counting every input and output token, no 5-hour rolling window, and no weekly cap resetting on a schedule to track. Send more requests than a plan's stream count and they wait briefly in a fair queue rather than failing. Once subscribed, a plan's price and stream count stay fixed for 12 months, and any later change comes with 30 days' notice by email. Current plans and stream counts are on the pricing page.

The model behind it, Qwen3.8-27B, is upfront about where it sits. On Qwen's own model card, it trails Anthropic's Opus 4.6 Max on Terminal Bench 2.1 (73.0 vs 78.2) and NL2Repo-Bench (42.3 vs 47.6), and edges ahead on LiveCodeBench v6 (90.3 vs 88.8). The SWE-bench Pro comparison (61.7 vs 53.4) is messier: Opus's figure is Anthropic's own reported score, while Qwen re-ran the other three benchmarks on a corrected suite, so that one pairing isn't perfectly apples-to-apples. Those are also full-precision, model-card numbers. NeverMetered serves a 4/5-bit quantized build that can score a little lower, and its own live evals against full precision are still in progress. In short: strong for its size class, not a frontier replacement.

Which is the honest pitch for where it fits: keep a Cursor Pro, Pro+, or Ultra seat for the genuinely hard problems, and send the routine agent work, tests, refactors, docs, long-running jobs, somewhere that doesn't have a pool to watch. Cursor is one of 19 tools NeverMetered has a setup guide for, and it connects over the same kind of OpenAI-compatible endpoint Cursor already speaks; see the Cursor integration guide for the setup. Weighing this against running a model locally instead? The local-LLM guide covers that tradeoff, and the comparison hub has more detail on how the options stack up.