Most AI code editors work the same way: you type a prompt, the model outputs code, you paste it in. Cursor Agent works differently — it reads your codebase, makes edits directly, runs terminal commands, and reports back when something is done. This guide covers how that actually works, what you can ask it to do, and where the boundaries are.
What Makes Cursor Agent Different From Autocomplete
Cursor started as an AI-powered code editor with autocomplete suggestions. Agent mode, introduced through Cursor’s documentation, is a separate capability: a persistent conversation with a model that has access to your project files, a terminal, a web browser, and a set of tools that let it take actions rather than just suggest them.
The distinction matters in practice. With autocomplete, every change is something you copy, review, and apply yourself. With Agent, you describe a goal and the model works toward it across multiple steps — reading files, running shell commands, writing and editing code, and showing you the results — until the task is complete or you redirect it.
Cursor Agent is built around three components, as documented on cursor.com/docs: instructions (your prompts and any rules you set), tools (file search, editing, terminal, browser), and a model. The model layer is tunable — you can swap between different frontier models depending on your plan.
Cursor’s Subscription Plans After October 2026
Cursor updated its pricing on October 12, 2026, consolidating plans under a model called The X Subscription. The legacy Pro plan ($20/month) is still available to existing subscribers but is no longer offered to new signups.
The current individual tiers, as listed on cursor.com/pricing (read October 14, 2026):
– Free: $0 — limited Agent requests, Grok Chat, Grok Build. No credit card required.
– Plus: $8/month — Grok models only. Does not include Claude, GPT, or Gemini models.
– Premium: $30/month — the tier where third-party models (Claude, GPT, Gemini) and cloud agents become available. This is the closest equivalent to the legacy $20 Pro plan for developers who need non-Grok models.
– Super: $100/month — 15× the usage of Plus, priority model access during peak times.
– Ultra: $200/month — 50× the usage of Plus, earliest access to new features.
Third-party model usage (Claude, GPT, Gemini) is billed at API list price on top of the monthly subscription, regardless of tier. Bugbot code reviews became usage-based in May 2026, at approximately $1.00–$1.50 per review — the old $40 seat price is legacy.
Getting Started: Accessing Agent
Open the Agent panel with Cmd+I (Mac) or Ctrl+I (Windows/Linux) inside any Cursor project. This opens a side panel where you can type a natural-language instruction and watch the Agent work through it.
Cursor’s documentation describes the tools Agent has access to: file search and directory reading, codebase pattern matching, web search, file editing, shell command execution, browser control for screenshots and testing, image generation for UI mockups, and the ability to ask clarifying questions when it needs input from you.
For larger work — a full feature, a significant refactor, a migration — Cursor’s documentation recommends using a Project. A Project sets up a coordinator agent that plans the work and delegates sub-tasks, which keeps a multi-step objective organized rather than letting the model improvise across loosely connected edits.
Plan Mode: Structuring Work Before Acting
Plan Mode is where Cursor’s approach differs most from pasting prompts into a chat. When you activate Plan Mode, the Agent first reads the relevant parts of your codebase, generates a structured plan describing what it intends to do, and shows it to you before making any changes. You can then approve the plan, ask for changes, or redirect the work.
This matters for two reasons. First, it keeps the Agent from taking a wrong turn deep into a refactor before you notice. Second, it lets you align the model on scope — you can say “yes, but skip the tests” or “only touch the API layer” before any code is written.
Cursor’s documentation describes Checkpoints as a companion feature: snapshots taken automatically before significant changes. If the Agent makes a wrong turn, you can restore a checkpoint to revert file changes without losing your conversation history. Checkpoints are local and separate from Git — they are a rollback mechanism for the AI’s edits, not a version control substitute.
Keyboard Shortcuts That Matter Day to Day
The following shortcuts are documented on cursor.com/docs and are the ones most frequently referenced in the official documentation:
– Cmd+I — open the Agent panel (this is the primary entry point)
– Cmd+K — open the command palette for codebase search, a faster alternative to panel-based navigation
– Cmd+L — open the main chat panel, useful for questions that don’t need Agent-level tool access
– Enter (while Agent is running) — queue a follow-up message to be processed after the current task finishes
– Cmd+Enter (while Agent is running) — send a message immediately, bypassing the queue, attaches to the most recent user message in the transcript
The queue behavior is worth knowing: when Agent is mid-task, a regular Enter queues your message after the current step. Cmd+Enter interrupts more aggressively by appending to the most recent user message and processing right away. For urgent redirections — “stop what you’re doing and fix this” — Cmd+Enter is the right key.
Side chats are available via typing /side or /btw in the chat input, or using the plus button in the chat panel header. A side chat is a durable agent conversation that uses the parent thread as hidden reference context. You can @-mention a side chat from the main thread to pull that context back in.
Example Workflow: Fixing a Bug Across Multiple Files
A typical Agent session for a bug fix follows this pattern, based on descriptions in the official documentation rather than a recorded test:
1. You open the Agent panel (Cmd+I) and type: “Find the source of the null reference error in the payment module and fix it.”
2. Agent searches your codebase for the error pattern, reads the relevant files, and proposes a fix plan.
3. You review the plan and approve it (or ask for adjustments).
4. Agent edits the files, runs your test suite, and reports the result.
5. If tests pass, you review the changes. If they fail, Agent can iterate.
The practical value of the Agent here is step 1 — finding the relevant files without you needing to know exactly where the bug lives. For a codebase you didn’t write, or one you inherited, this alone saves significant manual grep-and-read time.
Where Agent Falls Short
Cursor’s documentation is explicit about what Agent cannot do: there is no limit on tool calls during a task, but the quality of the output depends on the instructions you give it. Vague prompts produce vague plans. Ambiguous goals produce the wrong changes.
Agent is also not a substitute for understanding what it changed. Cursor’s documentation recommends reviewing every plan before approval, and reviewing every diff after execution. For code in production systems, this review step is not optional — the model will make changes that match your prompt but not necessarily your intent.
The context window is a practical limit. As of October 2026, models in Cursor support up to 1M token context windows (varies by model and plan). Large codebases can approach this limit in long sessions, and when context fills up, earlier parts of the conversation may be less accessible to the model.
FAQ
Q: Can I use Cursor Agent with models other than Claude?
Yes, on the Premium ($30/month) plan and above. The Plus tier ($8/month) is Grok-only and does not include Claude, GPT, or Gemini models. Third-party model usage is billed at API list price on top of the monthly subscription.
Q: How is Cursor Agent different from the /claude-code command in a terminal?
Cursor Agent runs inside the Cursor editor with direct access to your open project files, terminal, and browser. Claude Code runs as a standalone CLI application. Cursor Agent is designed for in-editor workflow integration; Claude Code is designed for terminal-first workflows. The underlying model capabilities overlap significantly.
Q: Does the Agent have a usage limit?
Usage limits depend on your subscription tier. The Free tier includes limited Agent requests. Paid tiers give higher usage pools. Specific RPM/TPM limits are visible in your Cursor settings. Third-party model usage (when using Claude, GPT, or Gemini) is also subject to the model’s own API rate limits.
Q: Can I connect Cursor to my own API keys?
Yes. Cursor supports bringing your own API keys for third-party models on applicable plans. This lets you control spend beyond the included usage pools. Details are in Cursor’s settings documentation.
Q: Does Cursor work offline?
Cursor requires an internet connection for Agent mode, since it communicates with model APIs. Basic autocomplete may work offline for some language servers, but the full Agent capability depends on cloud model access.
