Self-gathering, hand-pinning, and chat as your session

Self-gathering context

The headline change in Cursor 2.0 is that you often don’t have to point at anything at all. Self-gathering context (agentic retrieval) means the agent pulls its own context - it searches the codebase, reads the files it decides are relevant, and follows references on its own, rather than waiting for you to @-tag everything up front. The 2.0 changelog puts it directly: the agent “can now self-gather context without needing to manually attach it in the prompt input” - which is exactly why the older @Web, @Definitions, @Link, and @Linter Errors menu items were retired. (source)

What this looks like in practice: you describe the problem in plain language and let the agent find the code.

> transactions from one feed show up with no merchant name. everything
  else gets one. find why and fix it.

  • Searching: merchant, payee, counterparty
  • Reading apps/worker/src/extract.ts, apps/worker/src/fetch.ts
  • Reading packages/shared/src/transaction.ts

  The extractor reads the payee field, but this feed serves it under the
  key "counterparty" instead of the spec's "merchant". The selector only
  matches merchant=, so the merchant name is dropped…

No @-tags. You named a symptom; the index plus agentic search found extract.ts - a file you might not have known to point at. On a repo you don’t fully know yet (and an inherited budgetcli is exactly that), self-gathering is often better than hand-pinning, because the agent’s search isn’t limited by your incomplete mental map of the layout. The honest rule: for “find where X happens” problems on familiar-enough code, describe the problem and let it gather. Reaching for @-tags first, out of habit, can actually narrow the agent to a worse slice than it would have found itself.

But “often better” is not “always.” There are cases where retrieval reliably guesses wrong, and knowing them is what turns two gestures into one skill.

When hand-pinning still wins

Self-gathering is a retrieval heuristic, and heuristics have failure modes you can predict. Two cases where you should pin context by hand rather than trust auto-gather:

1. Large or sprawling repos, where retrieval surfaces the wrong slice. The bigger and more uniform the codebase, the more ways there are for semantic search to land in a plausible-but-wrong neighbourhood. budgetcli has three packages that all have a client.ts; a query about “the API client” can pull the API surface’s fetch wrapper when you meant the worker’s upstream HTTP client. The agent then reasons fluently about the wrong file. Symptom to watch for: the agent’s edits touch a package you didn’t expect. The fix is to stop describing and start pointing - @-attach the folder apps/worker/ or the file apps/worker/src/http.ts - to fence retrieval into the right subtree.

2. Ambiguous symbols, where a name resolves to the wrong definition. This is the sharpest case. budgetcli defines parse() in the worker’s feed extractor and re-exports a different parse() from a shared util. Ask the agent to “fix parse” and self-gathering has to guess which one you mean from surrounding context - and it can guess wrong, confidently, because both are real. Cursor used to offer a by-name symbol attachment (@Code) for exactly this, but that menu entry was removed around the 2.0 release, so the durable disambiguation move today is to pin the file that holds the right definition and name the symbol in prose - the file scope rules out the other parse() even though you can’t pin the function directly:

> the feed extractor's parse() drops the amount field on pending rows.
  fix parse() in @apps/worker/src/extract.ts - not the shared util's parse.

  • Reading apps/worker/src/extract.ts

  Fixing the pending-row branch in this file's parse()…

The pattern under both: auto-gather is a guess; hand-pinning is a constraint. When the cost of the agent guessing wrong is high - a big repo where wrong means “edited the wrong package,” or an ambiguous symbol where wrong means “fixed the wrong function” - spend the two seconds to pin and remove the guess. When the cost is low and your map of the code is incomplete, let it gather. That judgement, not a rule about always- or never-tagging, is the skill.

Continuity: the chat is your session

Everything above lives inside a chat, and in the editor the chat is also your continuity layer - Cursor keeps a history of past conversations you can reopen, so context you built up doesn’t vanish when you switch tasks or close the window. The deliberate move that matters here is the opposite of resuming: start a new chat when you switch tasks. A fresh chat gives the agent a clean window with none of the previous task’s material - which both improves output and delays hitting the context limit. Cursor can compact a conversation to free up space in the context window (the CLI exposes this as /summarize, with /compress as an alias), but compaction is lossy, so you’d rather not lean on it for unrelated work. Riding one long thread across three different bugs is how the agent goes hazy; a new chat per task is how you keep each window sharp. Here’s that judgment made visible - a session playing out with its context window x-rayed, pausing where you’d have to decide. The commands wear generic names; in Cursor, /compact is the CLI’s /summarize (/compress is an alias), and /clear is starting a new chat:

One session, played back with its context window x-rayed. Watch what the work costs on the right; when the playback pauses, you decide what the session does next - then replay the other choices.

0k / 200k

Fixed overheadRulesConversationFile readsTool outputSummaries

agent session - billing-app

agent cli · new session · repo: billing-app

the window, x-rayed

Every number is an illustrative order of magnitude, and the commands answer to different names across tools - /compact, /compress, or /summarize; /clear, /new, or a fresh chat. The trade is the same everywhere: a reset is coming, and choosing its moment - and what survives it - is yours to keep.

This is also where the editor and the CLI differ in ergonomics - though less than you’d expect. Cursor documents the CLI under both agent and cursor-agent across CLI generations, so use the executable installed by your current version. It does not trade the @ primitive for flags: its docs describe selecting files and folders with @, the same attach gesture as the editor. The CLI also has terminal-native slash commands for session continuity, but the exact inventory is version-sensitive; check the current reference before teaching /new-chat, /resume, /fork, or /summarize. (CLI reference)

If you want the spec-level view of how any of these primitives are defined across tools, that’s Foundations: context window management. This chapter was the muscle memory: see the substrate once, point when you know, let it gather when you don’t, and take the wheel back the moment the stakes of a wrong guess go up.

What the agent sees is one dial. Which engine reads it - and what that engine bills you for the turn - is the next one. Next: models, Auto, and billing.