Mid-task, Cursor pauses with "rate limited by model provider, retrying". This is not your 500 fast requests running out. It is the model provider behind Cursor (Anthropic, OpenAI, or whoever serves the selected model) throttling the request itself, and the fix starts with understanding that these are two different walls.
Two different limits, one editor
- Cursor's own request pool. Pro includes 500 fast premium requests per month. Exhaust it and Cursor tells you directly, in its own words.
- Upstream provider throttles. The "rate limited by model provider" message means the provider serving your model pushed back on the request. Your request pool is untouched; the pipe to the model is congested.
The retrying suffix matters. Cursor is re-sending the same oversized request automatically, so every retry pushes the identical heavy payload again: throttle pressure and token spend compound while you watch the spinner.
Why agent requests get throttled hardest
Providers throttle on payload size, request rate, and shared capacity at peak. Agentic coding is the worst possible case for all three:
- Huge payloads. The agent reads a 2,000-line file to tweak one function. A "small" question becomes a 20,000-token request, and every subsequent turn re-sends the growing conversation history on top.
- Rapid bursts. Agent loops fire consecutive requests seconds apart: read, edit, run, read again. Burst limits were sized for chat, not for machines that never pause to type.
- Peak-hour capacity. Midday demand on shared provider capacity makes throttles trigger more easily on exactly the payloads that were already borderline.
Exact thresholds are not published and they shift with load. Treat any fixed number you see as folklore and fix the shape of your requests instead: smaller payloads get throttled less, everything else is a workaround.
Fixes, ranked by what actually works
- Shrink the payloads. Slice file reads locally so the request carries the function being edited plus typed signatures, not 2,000 lines of bystanders. Measured read reductions run from -85% to -99% across 15 real repositories in the public benchmark.
- Break the retry loop. If a request just got throttled, immediately resending the identical payload multiplies the problem. Shrink the next step, or pause and resume with a smaller task.
- Stagger parallel agents. Three background agents on one account look like a burst attack to a provider. Queue them.
- Off-peak for batch work. Test sweeps and long refactors run cleaner in the morning hours than at the midday peak.
- BYOK as an escape hatch, not a strategy. Plugging your own provider API key into Cursor bypasses Cursor's pool, but you pay provider rates per token. An unsliced session on BYOK just moves the same oversized bill to your invoice. Slice first, then BYOK only if you still need it.
The measured shape of the fix
Local AST slicing keeps the target function and its 1-hop type contracts intact while folding unrelated bodies into one-line signatures. In a reference harness across 10 agent tasks, context spend dropped from 169,761 raw tokens to 8,178, a -95.2% reduction with the worst single operation at -99.4%. Smaller requests are cheaper, faster, and far less likely to trip a provider throttle, because the throttle is triggering on the payload you no longer send.
The repeat-read cost math behind this is in Stop paying for code your agent already read, and the team-level economics are modeled in what a 10-seat Cursor team actually costs.
Set it up
npx tokensafe@latest init
TokenSafe hooks into Cursor locally, slices reads before they become requests, and blocks the destructive retry loops that make throttles worse. See the quickstart docs or start a 7-day team trial to keep a whole team off the throttle wall.
"Rate limited by model provider" is a payload problem wearing a throttle costume. Shrink what you send, and the throttle stops finding you.