The Workshop · 12 min mission

Cursor Essentials: Tab, Agent, and the Model Picker

Learn the four surfaces of the Cursor editor — Tab, Chat/Agent, the mode picker, and the model picker — plus its pricing tiers, in one sitting.

cursoride-agentstabagentmodel-pickerpricingFact-checked 2026-06-15
On this page

Cursor is an AI code editor: a VS Code fork (built by Anysphere) with an agent in the core. Four surfaces do almost all the work — Tab (inline completion), Chat / Agent (Cmd+I), the mode picker (Shift+Tab), and the model picker. This guide gives the exact keybindings, modes, model names, config files, and prices to operate each, current as of 2026-06-15 (Cursor 3.7).

SurfaceInvokeWhat it does
TabTab (inline)Multi-line AI completion: edits, adds imports, jumps across files
Chat / AgentCmd+IPlans and edits across the repo, runs the terminal
Mode pickerShift+TabCycles Agent / Plan / Ask
Model pickerDropdown in chatSelects Auto, Composer, or a frontier model
The four surfaces and how you invoke each. Cursor is a VS Code fork, so existing extensions, keybindings, and settings carry over.

The 3.x Agents Window

On April 2, 2026, Cursor 3.0 introduced the Agents Window — a surface "centered around agents, while keeping the depth of a development environment." Open it with Cmd+Shift+P → Agents Window; toggle back to the classic IDE at any time. 3.0 added running many agents in parallel "locally, in worktrees, in the cloud, and on remote SSH," plus the /worktree (isolated changes) and /best-of-n (same task in parallel across models, each in its own worktree) commands.

Naming trap: in pre-3.0 tutorials "Composer" named the multi-file chat panel. In current Cursor the panel is just Agent (or Chat); Composer now names Cursor's own family of models (Composer 1 → 2.5).

VersionDateHeadline feature
3.0Apr 2, 2026Agents Window; parallel agents; /worktree, /best-of-n
3.1Apr 15, 2026Canvases (interactive agent artifacts)
3.2Apr 24, 2026/multitask (async subagents)
3.3May 7, 2026PR Review / Split PRs
3.4May 13, 2026Full-screen tabs; compact chat responses
3.6May 29, 2026Auto-review (longer runs, fewer approval prompts)
3.7Jun 4–5, 2026Design Mode in canvases; Context Usage Report
Cursor 3.x release timeline, from cursor.com/changelog (verified 2026-06-15). 3.7 is the current version.

Tab: completion that rewrites

Tab reads your recent edits, surrounding code, and linter errors, then proposes changes that can modify multiple lines, add missing imports, and coordinate edits across related code. Jump-in-file: after you accept, pressing Tab again predicts where your next edit belongs and jumps the cursor there. Cross-file suggestions: Tab can predict an edit in a different file and surface it in a "portal" window. Tab runs on a custom model Cursor trains itself (the docs page does not name the production model); per Cursor's engineering blog the next-generation model is Fusion, the system runs 400M+ predictions/day, and it is improved with online reinforcement learning on live accept/reject feedback.

ActionKeys
Accept the suggestionTab
Reject itEsc (or keep typing)
Accept word-by-wordCmd/Ctrl + →
Jump to the next predicted editTab again, after accepting
Turn Tab on/offStatus indicator (bottom-right), or Cursor Settings → Tab
Tab keybindings. Toggle Tab from the bottom-right status indicator or Cursor Settings → Tab.

Chat & Agent

Open with Cmd+I. The Agent "can complete complex coding tasks independently, run terminal commands, and edit code." It is built from three parts: Instructions (system prompt + your rules), Tools, and a user-selected Model.

ToolWhat it does
Codebase searchSemantic search across the repo
File / folder searchLocate files and directories by name
File editingEdits applied automatically to your files
TerminalRuns shell commands and monitors output
Web searchFetches information from the web
Browser controlScreenshots, navigation, visual UI verification
Image generationGenerates images
Rule retrievalPulls in matching .cursor/rules entries
Agent tools (cursor.com/docs/agent/overview). Mutating actions are auto-applied; a checkpoint is saved first.

Context with @-symbols

Type @ in the chat box to attach context instead of pasting it. You can also drop in images and voice, and switch models mid-chat without losing the thread.

@-symbolAttachesExample
Files & FoldersA file or directory@auth.ts, @src/components/
@DocsIndexed documentation@Docs
@TerminalsTerminal output@Terminals
@Past ChatsA prior conversation@Past Chats
@Commit / @BranchGit diffs@Commit, @Branch
@BrowserThe in-agent browser@Browser
@-symbols available in chat (cursor.com/docs/agent/prompting).

Modes: Agent, Plan, Ask

The same chat surface runs in three modes; cycle them with Shift+Tab (or the mode-picker dropdown). The mode decides whether the agent edits immediately, plans first, or cannot edit at all.

  • Agent — standard mode; goes straight to implementing changes. Use when you can describe the change precisely.
  • Plan — "creates detailed implementation plans before writing any code." Asks clarifying questions, researches the codebase, and shows an editable plan before building. Use for complex, multi-file, or architectural work.
  • Askread-only; answers questions and searches the codebase without editing (can use a read-only terminal, e.g. to inspect git history). Use to understand unfamiliar code first.

Plan mode vs Agent mode

Plan mode (think first)

Best for: a refactor across several files, a new feature, anything architectural.

Researches, asks clarifying questions, and shows an editable plan before any line changes. You approve the approach, then it builds. A wrong turn is cheap to fix in the plan.

Agent mode (edit first)

Best for: a precisely-describable change — "rename this prop everywhere," "add this validation to signup.ts."

Skips the plan and edits immediately. Faster when the task is small and unambiguous; you review the result instead of the intent.

Knowledge check

You want to add OAuth login across the auth module, the API layer, and the UI — and you are not yet sure of the cleanest approach. Which mode (cycled with `Shift+Tab`) should you start in?

Model picker: Auto, Composer, frontier

The picker selects the model that drives the Agent and exposes three kinds of choice:

  • Auto — "allows Cursor to select models that balance intelligence, cost efficiency, and reliability." It is a router, not a single model, and draws from the flat Auto + Composer usage pool. Token rates: $1.25/1M input, $6.00/1M output, $0.25/1M cache read.
  • Composer (Cursor's own) — Composer 1, 1.5, 2, 2.5. A mixture-of-experts model RL-trained for agentic coding; Cursor positions it as a "Fast Frontier" model with generation speed ~4× faster than similar models. Cursor's blog lists GPT-5 and Sonnet 4.5 as "Best Frontier" models that outperform Composer on capability — the trade is speed vs. raw capability.
  • Frontier models — five external providers (table below). The roster churns weekly; treat it as a 2026-06-15 snapshot and confirm on the live models page.
ProviderRepresentative models in the picker
CursorComposer 1 / 1.5 / 2 / 2.5 (in-house, "Fast Frontier")
AnthropicClaude Opus 4.8, Claude 4.7/4.6/4.5 Opus/Sonnet/Haiku, Claude 4 Sonnet (+ 1M), Claude Fable 5
OpenAIGPT-5.5, GPT-5.4 (+ Mini/Nano), GPT-5.3 Codex, GPT-5 family
GoogleGemini 3.5 Flash, Gemini 3.1 Pro, Gemini 3 Pro/Flash, Gemini 2.5 Flash
xAIGrok 4.3, Grok 4.20, Grok Build 0.1
MoonshotKimi K2.5
Frontier providers in the picker, as of 2026-06-15. Point releases change constantly — confirm against cursor.com/docs/models-and-pricing before relying on a name.

Rules: keeping the agent on-style

Cursor reads project rules so the agent follows your conventions automatically. Rules live in .cursor/rules/ as .mdc files (version-controlled; can nest in subfolders). Each file's frontmatter has three keys — alwaysApply (bool), description (string), globs (file-pattern string) — and those decide when the rule fires. As a simpler alternative, Cursor also reads a single plain-markdown AGENTS.md at the project root (no frontmatter).

TypeFrontmatterFires when
Always ApplyalwaysApply: trueInjected into every request
Apply Intelligentlydescription, no globsAgent judges the rule relevant
Apply to Specific Filesglobs setA matching file is in play
Apply ManuallyNo description/globsYou @-mention it on demand
The four rule application types and the frontmatter that selects each (cursor.com/docs/context/rules).
.cursor/rules/typescript.mdc — an "Apply to Specific Files" rule
markdown
---
description: TypeScript conventions for the web app
globs: src/**/*.ts,src/**/*.tsx
alwaysApply: false
---
 
- Prefer `type` aliases over `interface` for component props.
- No `any`. If a type is genuinely unknown, use `unknown` and narrow.
- Co-locate a component's test as `<name>.test.tsx` beside it.
- Run `npm run lint` before declaring a change done.
a first Plan-mode session
… scroll to run this session
Plan mode explores with read-only tools first, then waits for approval before editing.
PlanPriceWhat you get
HobbyFreeLimited Agent requests and Tab completions
Pro$20/mo$20 API credit + Auto/Composer pool, unlimited Tab, frontier models, MCP, cloud agents
Pro+$60/mo$70 API credit; for daily agent users
Ultra$200/mo$400 API credit + priority access to new features
Teams (Standard)$40/user/moCentral billing, SSO (SAML/OIDC), team context, usage analytics
Teams (Premium)$120/user/mo Standard Agent limits + a $0.25/1M Cursor Token Rate on non-Auto requests
EnterpriseCustomPooled usage, SCIM, access controls, audit logs, priority support
Cursor plans, USD, as of 2026-06-15 (cursor.com/help/account-and-billing/pricing). "API credit" is the included allowance for external frontier-model calls, separate from the flat Auto + Composer pool.

Reach the end and this star joins your charted sky.