Cursor Context Window Size, Explained

Cursor context window size is the token limit of the model you selected in Cursor, not a separate Cursor specification. A Claude-class model in the picker is typically a 200k-token window.

Some GPT-class options advertise larger ones. Cursor's job is to decide what to pack into that window.

People search this phrase because the chat UI shows a "context used" percentage and then the model gets dumber. The percentage is a packing report, not a promise that 200k tokens of your app are sitting there.

What does cursor context window size actually mean?

A token is a chunk of text, roughly a short word or a piece of a long one. Code tokenizes worse than English.

A 200-line React file can cost more than it looks.

The window is everything the model can attend to in one request: system prompt, rules, your messages, retrieved files, tool results, images, and the model's own earlier turns if they were replayed.

Cursor does not publish one immortal number on a marketing page and keep it forever. When you change models, the window changes with the model.

If you want the UI string decoded, I already wrote what "context used" means in Cursor and the shorter Cursor context used note.

Default chat

Window: whatever the selected model advertises

Who fills it: Cursor's system prompt, rules, open-file hints, your thread

Feel: fine until the thread is long or you @-mention a folder

Max mode

Window: more of the same model limit, fewer of Cursor's own shortcuts

Who fills it: you, plus whatever you @-mention

Feel: better for hard multi-file work, worse for your bill

@Codebase / repo retrieval

Window: still the model limit

Who fills it: retrieved chunks, not the whole git tree

Feel: great when the index is right, silent-wrong when it is not

How big is the window for common Cursor models?

I will not invent a benchmark. I will tell you the shape.

Claude Sonnet and Opus class models that Cursor exposes are usually 200k tokens. That is the number you should plan around for most paid Cursor work in 2026.

Some OpenAI models in the picker advertise larger windows (hundreds of thousands to around a million on paper). "On paper" matters.

The useful working set is smaller than the billboard, because the model still has to pay attention, and Cursor still has to pay for the tokens.

Local or cheap fallback models can be much smaller. If the picker suddenly feels forgetful after you swapped models, check the window before you rewrite your rules file.

Composer / Agent mode uses a working context that is not "paste the monorepo." It walks files, calls tools, and keeps a running plan. Tool results replace each other.

That is why an agent can touch twelve files without ever holding twelve files at once.

@Codebase is search, not a dump. If the wrong chunk comes back, a 200k window will not save you.

What actually fills the window?

In order of how fast I have seen it burn:

1. Images. A full-screen PNG is a lot of tokens for a little signal.

I wrote the cousin of this problem for Claude Code in screenshots waste tokens. Same physics in Cursor.

1. Long chat threads.

Every "try again" you left in the thread is still sitting there unless you start a new chat.

1. Fat @-mentions.

@src on a real app is how you discover that "include the folder" was a wish.

1. Rules and always-on docs.

A 2,000-line rules file is a tax on every turn.

1. MCP tool payloads.

A useful payload is small and named. A JSON blob of the entire accessibility tree is not.

1. The model’s own previous plan text, replayed.

The same discipline applies if you hand context to Claude Code instead of Cursor. How to give Claude Code context is the terminal version of this advice.

Does a bigger window fix the wrong-element problem?

No.

A bigger window lets the model hold more files. It does not tell the model which Button on screen you meant.

If you paste a screenshot of the whole window, you have spent tokens on the menu bar and the other panel so the model can still invent a class.

macOS already has the answer under the pointer. PinVari (hotkey ⌥⌘A) circles the control, transcribes on-device, and resolves the AX node: role, label, frame, confidence, circled-versus-dwelled.

Deictic words bind to the pointer timestamp.

The local MCP connector lives at ~/.pinvari/mcp/pinvari-mcp. PinVari → Connect → Cursor, or a user-scope add.

The app must be running on 127.0.0.1:3402.

pinvari_next_instruction

returns a cropped shot plus a named path, not 40,000 characters of unrelated window text unless you asked for the focused-window dump. You can get up to 40,000 characters of focused-window text, including text scrolled out of view.

You should not lead with that.

If you want a one-time Mac app that does this without an API key, the pricing block is the only product link in this post.

How should you spend a 200k window on a real app?

My working budget, not a vendor spec:

Always-on (small): a short rule file. Stack, test command, "do not rewrite unrelated files."

Per task: two to five files you @-mention by name, not a directory.

Visual bugs: one cropped screenshot and one named element. Not the whole desktop.

Repo questions: @Codebase with a precise question. "Where is the billing toggle rendered?" not "read the app."

Agent work: let the agent open files. Do not pre-stuff twenty.

If the context bar climbs past the point where answers get vaguer, I start a new chat and keep only the constraint that was true.

Tight context beats a full window on UI work. I have never seen a visual bug that needed 180k tokens of CSS.

A packing checklist I actually use

New chat when the last plan was wrong

Named files instead of folders

Crop instead of desktop PNG

Rules under a page instead of a novella

MCP results that name an element instead of a pixel dump

What happens when you blow the cursor context window size?

Cursor does not always hard-error. More often the older turns get summarized or dropped, the agent "forgets" a file it already edited, and you watch it re-introduce a bug you already rejected.

That is why the context-used bar climbing is useful even when the request still "succeeds." Success here means a response came back, not that the working set is still the one you intended.

I treat anything past a comfortable mid-bar as a cue to checkpoint. Write the one-sentence goal at the top of a new chat.

Link the two or three files that still matter. Leave the archaeology behind.

Agent mode can look immune because it keeps opening files. It is not immune.

Each tool result shoves something else out. If pinvari_next_instruction returned a clean element and you then dumped git diff of the whole monorepo into chat, you just buried the clean element.

The failure mode I see on Electron apps is the opposite: people attach nothing named, attach a 5x retina PNG, and then add @src. The window is full.

The AX label never arrived. The model picks .btn-primary from memory of every other codebase it trained on.

You cannot debug that by buying Max mode. You debug it by sending less, named better.

If confidence on a capture is below about 0.8, the right move is to circle again or dwell longer (~0.2s) so the resolver can leave the bare AXGroup and find a labeled descendant. Guessing from a blurry crop is how the 200k window fills with noise.

FAQ

What is the cursor context window size in 2026?

It is the selected model's limit. Plan on about 200k tokens for Claude-class models in Cursor.

Check the model picker and Cursor's current docs when you switch, because the number is not Cursor's to freeze.

Does Max mode increase the context window?

Max mode uses more of the model's existing window and reduces some of Cursor's own summarization. It does not invent a larger model.

You pay more to waste more if you attach junk.

Does @Codebase put my whole repo in the window?

No. It embeds and retrieves.

You get chunks that matched the query. Wrong chunks look like the model "has the repo" and still renames the wrong export.

Why does context used jump after I paste a screenshot?

Images are expensive. A retina capture of a full display can dwarf the file you cared about.

Crop to the control. Better, send a named AX element and a tight crop.

Is a 1M-token model in Cursor worth it?

For huge text dumps and long legal-style docs, maybe. For a Next.js UI bug, almost never.

The failure mode is still "wrong component," which is an addressing problem.

How do I see what Cursor put in context?

You cannot see a perfect itemized receipt for every hidden system token. You can see what you @-mentioned, what the agent opened, and the context-used bar.

Treat that bar as a smoke alarm, not a ledger.