# Cursor Usage Limits: Usage Pools, Plan Quotas, and Storage Workarounds

Cursor usage limits represent the monthly compute allocations across Cursor Models and Other Models pools, rate-limiting thresholds, and background codebase indexing allowances enforced by Anysphere. When model allowances deplete, requests transition to fallback queues or usage-based billing. This guide examines plan quotas across Hobby, Pro, Pro+, Ultra, and Teams tiers, and demonstrates how offloading reference documentation to Fast.io workspaces via remote MCP preserves model pools without sacrificing code context.

Source: https://fast.io/resources/cursor-usage-limits/
Author: [Derek Labian](https://fast.io/authors/derek-labian/)
Last reviewed: 2026-09-12

## How Cursor Enforces Usage Limits, Usage Pools, and Plan Quotas

When an automated coding workflow exhausts its monthly Cursor Models or Other Models pool midway through a complex refactor, Cursor does not immediately halt operation: the editor drops requests into a queued pool, introduces noticeable completion latency, and limits multi-file agent steps. Every session in Cursor operates within usage quotas established by Anysphere to balance compute expenses against developer throughput.

Cursor usage limits represent the monthly compute allocations across Cursor Models and Other Models pools, rate-limiting thresholds, and background codebase indexing allowances enforced by Anysphere.

To navigate these constraints effectively, software engineers must understand how Cursor meters compute resources. While early versions of Cursor relied on simple monthly request counters, the modern platform evaluates consumption across distinct model pools and infrastructure layers:

1. The Cursor Models Pool. First-party and tuned models, such as Grok and Composer models, draw from an inclusive monthly allowance designed for rapid, everyday code completion, inline generation, and general repository navigation.
2. The Other Models Pool. Frontier third-party models, including Claude and GPT variants, are metered against explicit monthly credit allowances or legacy request quotas. Once this allocation is exhausted, queries fall back to throttled slow request queues or require pay-as-you-go credit additions.
3. Background Indexing Allowances. Background repository indexing computes vector embeddings to power semantic codebase queries. Large repositories with thousands of files consume local CPU cycles and background indexing bandwidth, introducing index refresh delays when repositories change rapidly.
4. Inline Editing and Composer Agent Loops. Autonomous agent loops in Cursor Composer execute multi-turn conversations. Each turn sends accumulated conversational history, tool outputs, and modified file buffers back to the model, consuming quota increments rapidly.

The table below summarizes the operational limits and throttling behavior across Cursor subscription plans:

| Plan Tier | Monthly Price | Included Model Pools | Rate Throttling Behavior | Context & Agent Allowances |
| :--- | :--- | :--- | :--- | :--- |
| Hobby (Free) | $0 | Basic Cursor Models pool, 2,000 completions | Limited access to frontier models | Standard context window, single-file edits |
| Pro | $20 monthly | Included Cursor Models and Other Models pools | Queued slow requests or Max Mode billing | Full Composer agent, multi-file editing |
| Pro+ | $60 monthly | Expanded Cursor Models and Other Models pools | Queued fallback or credit refill | Extended agent loops, priority queue access |
| Ultra | $200 monthly | Maximum Cursor Models and Other Models pools | Highest priority queue access | Deep reasoning models, continuous agent workflows |
| Teams (Standard) | $40 per seat monthly | Centralized Cursor Models and Other Models pools | Shared team dashboard, usage analytics | Team administration, standard agent quotas |
| Teams (Premium) | $120 per seat monthly | Centralized pools plus 5x Standard agent limits | Dedicated priority access during peak hours | 5x Standard limits on Agent models |

Cursor extends context window token limits and model tokens on legacy plans through Max Mode billed at the model API rate plus 20%. Modern plans manage context boundaries through explicit model selection and credit spending limits. However, increasing credit budgets does not eliminate the core problem of inefficient context consumption: when an agent wastes prompt tokens re-reading unindexed local files, monthly allowances disappear prematurely regardless of your subscription tier.

## Why Codebase Indexing and Context Stuffing Deplete Request Quotas

Many developers assume that Cursor usage limits are exhausted solely by high prompt volume. In practice, the primary driver of premature quota exhaustion is prompt context stuffing caused by unoptimized codebase indexing.

When a developer types `@codebase` or initiates an agent task in Composer, Cursor performs semantic retrieval across the local repository. The background indexer scans source files, chunks text into logical blocks, computes embeddings, and stores them in a local vector database. When the agent formulates a plan, it queries this vector index and injects matching code blocks into the system prompt.

If a repository is clean and modular, this retrieval mechanism works efficiently. However, modern software projects routinely accumulate large reference assets: OpenAPI specifications, database schema dumps, generated SDK client libraries, test fixture JSON documents, and architectural documentation. When these non-code assets reside in the repository without exclusion rules, they trigger a cascade of quota-draining behaviors:

1. Bloated Semantic Search Results. When an agent queries the codebase for an authentication interface, the vector search engine frequently matches hundreds of lines from raw JSON fixtures or auto-generated API specifications instead of core application logic.
2. Attention Degradation Across Long Prompts. Transformers process tokens non-uniformly. In the lost-in-the-middle phenomenon, models allocate strong attention weights to the beginning and end of a context payload, while information in the middle suffers from reduced recall. Injecting massive reference files into the prompt pushes foundational architectural constraints into this neglected middle zone.
3. Multi-Turn Context Compounding. In an autonomous Composer session, the agent does not execute a single isolated prompt. It runs an iterative loop: reading files, proposing diffs, executing build scripts, inspecting test failures, and revising code. Because each subsequent turn includes the full conversational history and accumulated tool outputs, prompt payload sizes grow exponentially.

Consider the progression of token consumption in a typical four-turn debugging session on an unoptimized project:

```text
Turn 1: Developer requests an update to client billing logic.
Agent scans directory tree and reads billing controller.
Context payload: 14,000 tokens.

Turn 2: Agent attempts to reconcile database models.
Agent ingests raw schema dump and migration logs.
Context payload: 48,000 tokens.

Turn 3: Agent executes test suite; tests fail on validation errors.
Agent injects 2,000 lines of test output and OpenAPI specs.
Context payload: 92,000 tokens.

Turn 4: Agent applies multi-file diff and re-runs test assertions.
Context payload: 138,000 tokens.
Cumulative session consumption: 292,000 prompt tokens across 4 requests.
```

In this scenario, a single bug fix consumed nearly 300,000 prompt tokens, primarily because raw data fixtures and documentation were repeatedly passed through the model context. A developer executing ten similar tasks throughout a working day exhausts their monthly Pro allowance in less than two weeks.

This dynamic highlights the limitation of uncurated repository assets. In Claude Projects, project knowledge is limited by the context window, 30MB per file (see https://support.claude.com/en/articles/8241126-upload-files-to-claude). Cursor removed manual file boundaries by enabling whole-repository semantic indexing. However, removing file curation created a new failure mode: without careful asset selection, repositories bloat with multi-megabyte reference files that quietly drain usage allowances on every coding turn.

## Configuring Local Boundaries with .cursorignore and .cursorindexingignore

To prevent local files from consuming unnecessary indexing compute and bloating agent prompts, Cursor provides two configuration files: `.cursorignore` and `.cursorindexingignore`. Both files follow standard `.gitignore` glob syntax, but they govern different subsystems within the editor.

Understanding the operational boundary between these two files is essential for managing usage quotas:

* `.cursorignore` enforces a complete blocklist across all AI features. Files and folders matching patterns in `.cursorignore` are excluded from background indexing, Tab autocompletion, inline code generation, Composer agent tools, and chat `@file` mentions. The editor treats these files as invisible to the model.
* `.cursorindexingignore` restricts only the background semantic vector indexer. Files matching patterns in this file are not embedded into the local vector database, which saves local CPU cycles and prevents semantic search pollution. However, developers and coding agents can still explicitly reference these files using `@file` or direct file path prompts when specific lookups are required.

To establish clean boundaries, place `.cursorignore` in the project root to exclude build artifacts, dependencies, environment secrets, and heavy binary assets:

```text
node_modules/
dist/
build/
.next/
target/

fixtures/large_dataset.json
data/exports/
*.sql
*.sqlite
*.dump

*.log
coverage/
.nyc_output/

.env
.env.*
!.env.example
```

Next, configure `.cursorindexingignore` for files that contain useful reference information but should not be processed during automatic background embedding calculations:

```text
docs/openapi-spec.json
schemas/graphql-schema.json
reference/database-dictionary.md
docs/generated-reference/
```

For engineering teams maintaining monorepos with multiple sub-packages, Cursor supports hierarchical ignore rules. In Cursor Settings under the Indexing section, enable hierarchical ignore search. When active, Cursor applies `.cursorignore` rules found within subdirectories relative to each individual package root.

While local ignore configurations succeed at keeping editor indexing responsive, they create an architectural dilemma. When developers add API specifications, database dictionaries, or compliance guidelines to `.cursorignore`, the AI assistant loses access to the authoritative technical context required to generate functional code. Ignoring the file solves the local indexing bottleneck by blinding the agent to the domain rules it needs.

## Offloading Large Reference Corpuses to Fast.io Remote MCP Workspaces

The sustainable architectural solution for managing large reference corpuses is decoupling reference storage from the local code repository. Rather than forcing Cursor to index multi-megabyte documentation files on developer workstations, teams store their reference materials in a Fast.io workspace.

Fast.io provides shared, org-owned workspaces equipped with per-file version history, granular access controls, an append-only audit log, and native Intelligence Mode. You can populate a workspace by uploading files directly, or sync reference documents from Dropbox, Box, or OneDrive. Google Drive imports today with synchronization capabilities coming soon, enabling engineering teams to aggregate product requirements, API specifications, and architectural documentation without cluttering local Git folders.

When Intelligence Mode is enabled on a Fast.io workspace, every document is automatically processed for hybrid search, combining full-text keyword indexing with semantic vector retrieval. Instead of attaching monolithic files to Cursor prompts or exceeding local indexing quotas, the coding assistant connects to Fast.io through the Model Context Protocol (MCP) and retrieves only the exact paragraphs relevant to the current engineering task.

Cursor connects to remote MCP servers using Streamable HTTP. To integrate your Fast.io workspace with Cursor, create or update `.cursor/mcp.json` in your project root:

```json
{
  "mcpServers": {
    "fastio-reference-workspace": {
      "url": "https://mcp.fast.io/mcp/key",
      "headers": {
        "Authorization": "Bearer YOUR_FASTIO_API_KEY"
      }
    }
  }
}
```

The endpoint is also accessible via legacy SSE transport at `https://mcp.fast.io/sse`. Complete tool documentation is maintained at `https://mcp.fast.io/skill.md`, and integration patterns are detailed in the [Fast.io for Agents](/storage-for-agents/) documentation.

Connecting Cursor to an external Fast.io workspace provides decisive operational advantages over local repository storage:

* Elimination of Local Repository Bloat. Massive specification documents, compliance matrices, and historical changelogs reside in cloud storage rather than inflating local Git clone times.
* Targeted Semantic Retrieval. When an agent needs details about an API endpoint or database relationship, it executes a focused search query over MCP. Fast.io returns only the relevant excerpts, keeping prompt token payloads minimal and preserving included model pool allowances.
* Prevention of Attention Drift. Ingesting compact search results rather than fifty-page manuals keeps the model focused on immediate code instructions, eliminating hallucinated function signatures and broken diff applications.
* Unified Team Knowledge. In team environments using Cursor Teams subscription plans, where Premium seats add 5x the Standard limits on Agent models, team members share a synchronized, pre-indexed knowledge base rather than re-indexing identical reference assets locally across separate developer machines.

Connecting an external MCP workspace does not alter Cursor's internal plan quota or raise Anysphere's software limits. What changes is how efficiently those limits are utilized: instead of wasting hundreds of thousands of prompt tokens attaching raw files to chat windows, the assistant queries a remote index and retrieves only the precise lines of context required to complete the task.

## Structuring Technical References with Metadata Views and Team Governance

Engineering reference documentation frequently consists of semi-structured assets: vendor API registries, cloud service catalogs, database table definitions, and compliance requirements. While vector search excels at retrieving conversational prose, autonomous coding agents often require precise, structured parameters such as HTTP routes, request payload schemas, data types, and deprecation statuses.

To solve this requirement, Fast.io provides [Metadata Views](/product/document-data-extraction/). Metadata Views turn unstructured documents into a queryable, structured database. Users define required extraction fields in plain language, and Fast.io builds a typed schema supporting text, integer, decimal, boolean, URL, JSON, and date values. The platform automatically extracts these attributes across uploaded documents and organizes them into an interactive, filterable view.

Because Fast.io exposes Metadata Views directly through MCP, Cursor agents use the Fastio storage search tool (see mcp.fast.io/skill.md) to execute targeted structural queries instead of parsing raw prose. The agent queries views such as an API Route Registry for active billing endpoints and receives a structured JSON payload containing the exact route parameters, authentication headers, and response formats necessary to generate an API client. Developers can add new columns to a view at any point without re-uploading documents.

Beyond structured data extraction, Fast.io provides the operational governance required for production team workflows:

* Per-File Version History. Every modification performed by human engineers or automated coding agents is recorded as a separate revision. If an agent overwrites a configuration file or introduces an error, developers can inspect diffs and revert to prior versions immediately.
* Append-Only Audit Log. All read, write, search, and export operations are logged with timestamps and identity attribution, providing complete transparency into autonomous agent actions across the organization.
* Collaborative Notes. Real-time co-authoring enables engineers and AI assistants to draft architecture decision records, technical specifications, and release runbooks within a shared canvas.
* Scoped Ownership Transfer. External consultants and automation agencies can set up client workspaces, configure MCP connections, and transfer organizational ownership to the client upon completion while retaining administrative permissions.

Adopting Fast.io is straightforward. Every organization starts with a 14-day free trial, which requires a credit card. Plans are Starter at $29/mo, Business at $99/mo, and Growth at $299/mo, providing engineering teams with persistent cloud workspaces, automated intelligence, and remote MCP connectivity. You can review plan options on the [pricing page](/pricing/).

## Frequently asked questions

### What replaced Cursor fast requests, and how do usage pools work?

Cursor no longer sells a fixed count of fast requests. It allocates usage across two pools: Cursor Models (first-party models) and Other Models (frontier third-party models). Included usage allows immediate processing before requests fall back to standard queues. Pro subscriptions include allowances for both pools, while Pro+ and Ultra tiers provide expanded compute allowances.

### What happens when I use up my Cursor usage pool?

When an included Cursor Models or Other Models pool is exhausted, Cursor does not disable AI features. Instead, your requests transition to a throttled, slow queue where responses may experience processing delays during peak usage periods. Alternatively, developers can enable pay-as-you-go credit usage or Max Mode to maintain immediate processing speeds.

### How do Cursor Teams subscription limits differ from individual Pro plans?

Cursor Teams plans offer pooled usage across team members and centralized administrative controls. Teams Standard provides pooled Cursor Models and Other Models allowances per user, while Teams Premium adds 5x the Standard limits on Agent models, providing dedicated queue priority for engineering teams running intensive multi-file Composer workflows.

### What is the difference between .cursorignore and .cursorindexingignore?

The .cursorignore file acts as a complete blocklist, hiding matched files from codebase indexing, Tab autocompletion, inline code edits, Composer agents, and chat mentions. In contrast, .cursorindexingignore only prevents files from being embedded into the local semantic vector index, allowing developers to still reference them explicitly via @file mentions.

### Does offloading reference files to Fast.io raise Cursor's monthly usage limits?

No. Connecting a Fast.io workspace via MCP does not alter Cursor's internal plan quota or change Anysphere's software thresholds. Instead, it changes how context is retrieved: rather than pasting entire multi-megabyte files into chat prompts, the assistant searches the remote index and pulls only the exact excerpts needed, dramatically reducing prompt token consumption.

### How does remote MCP search prevent coding agents from exhausting context tokens?

Autonomous agents frequently consume tens of thousands of tokens per turn by re-reading whole local files. By querying a Fast.io workspace through MCP, the agent retrieves only specific paragraphs or structured metadata entries relevant to the active task, preventing prompt bloating, eliminating attention degradation, and extending monthly usage allocations.

## Sources

- [Cursor: Models & Pricing](https://cursor.com/docs/models-and-pricing) — Cursor extends context window token limits and model tokens on legacy plans through Max Mode billed at the model API rate plus 20%.
- [Cursor: Models & Pricing](https://cursor.com/docs/models-and-pricing) — Cursor Teams subscription plans offer a Premium seat that adds 5x the Standard limits on Agent models.

## About Fast.io

Fast.io provides shared workspaces where people and AI agents work on the same files, with built-in semantic search and citation-backed chat over what they hold. Agents reach it through a remote MCP server at https://mcp.fast.io/mcp, a REST API at https://api.fast.io/current/, and a command line client published on npm as @vividengine/fastio-cli.