Choosing and Switching AI Models
Choosing and Switching AI Models
Cursor is not locked to a single AI model. It supports models from several AI labs, plus its own, and lets you switch between them at any time. Knowing which model to reach for, and when, is one of the higher-leverage skills you can build as a Cursor user.
In this lesson, you will learn the main categories of models in Cursor, how Auto picks a model for you, how to switch models, how usage is counted, and a simple strategy for choosing.
What You'll Learn
- The main categories of models available in Cursor
- How Auto mode works and its Intelligence, Balance, and Cost settings
- What Composer is and why it is Cursor's own model
- How to switch models, including the Cmd+/ shortcut
- The tradeoffs between speed, quality, and cost
- How the Cursor models and Other models usage pools work
- A practical model selection strategy for everyday coding
Models Available in Cursor
The exact model list changes often, sometimes monthly, as labs release new versions. Rather than memorizing version numbers, it helps to think in categories. Open the model picker to see what is available right now.
Auto
Auto is not a single model. It is a router that picks a model for each request based on the task. Auto lets you choose what to optimize for:
- Intelligence: favors the most capable models, for the hardest work
- Balance: a middle ground between quality and cost
- Cost: favors cheaper, faster models to stretch your usage
Auto is billed at the list price of whichever model it routes your request to. For many developers, Auto on Balance is a sensible starting point.
Composer (Cursor's Own Model)
Composer is Cursor's own coding model, built and trained by Cursor for agent work inside the editor. It is designed to be fast at reading code, making edits, and running tools across many steps.
You may see older tutorials describe "Composer" as a panel for multi-file editing. That panel no longer exists; its features were merged into Agent. Today, Composer is the name of a model you can pick.
Frontier Models from AI Labs
Cursor also offers models from the major AI labs:
- Anthropic's Claude models: popular with developers for strong code understanding and careful instruction following
- OpenAI's GPT models: strong general coding and reasoning
- Google's Gemini models: strong reasoning and large context windows
- xAI's Grok models and others, depending on what Cursor currently offers
Each lab usually has a larger, more capable model and a smaller, faster one. Many also offer "thinking" or reasoning variants that work through a problem step by step before answering. Those are slower but better at complex logic.
Tab Completion
Tab completion uses Cursor's own specialized Tab model automatically. You do not choose it, and you do not need to. Its speed is what makes Tab useful.
How to Switch Models
Switching models takes a few seconds.
In the Agent Side Panel
The model picker sits in the chat input at the bottom of the Agent side panel. Click it to see the list and choose a model or Auto. You can also press Cmd+/ (Ctrl+/ on Windows and Linux) to cycle through your models without leaving the keyboard.
Agent side panel → Model picker (in the chat input) → Select model
Or: Cmd+/ to cycle models
You can switch mid-conversation. If you started with a fast model and hit a problem that needs deeper reasoning, switch to a more capable model for the next message. The conversation history carries over.
In Inline Edit (Cmd+K)
When you press Cmd+K, a small input bar appears in the editor. It also has a model selector, so you can pick a faster model for small edits or a stronger one for tricky changes.
In Any Mode
Agent, Ask, and Plan modes all use the same model picker. Model choice matters most in Agent and Plan, because those runs can be long and make many tool calls, which affects both quality and usage.
Managing Your Model List
In Cursor Settings → Models, you can turn models on or off so the picker only shows the ones you actually use. A short list makes Cmd+/ cycling faster.
Understanding the Tradeoffs
Choosing a model is about matching the tool to the task. Every model trades off speed, reasoning quality, and cost.
Speed
Faster models respond in seconds. Larger and thinking models can take much longer on complex tasks. Speed matters most for:
- Quick questions in Ask mode
- Simple edits like renaming variables or reformatting code
- Fast back-and-forth while you iterate
For these tasks, a fast model keeps you in flow. Waiting a long time for a simple rename breaks concentration.
Reasoning Quality
More capable models produce better results for:
- Complex algorithmic problems
- Designing a system or planning a large change
- Debugging subtle issues where the cause is not obvious
- Explaining unfamiliar code in depth
- Multi-step refactoring across many files
For these, the extra time and cost of a stronger model is worth it. A slightly wrong architecture suggestion can cost hours to untangle.
Cost
Larger models cost more per request than smaller ones, and thinking models use more tokens because they reason before answering. Long Agent runs with many tool calls also use more than a single question. Using the most powerful model for every message will use up your included usage faster.
Usage Pools: Cursor Models and Other Models
Cursor splits usage into two pools:
| Pool | What is in it | How it is counted |
|---|---|---|
| Cursor models | Composer, plus some partner models such as xAI's Grok models | Much more usage included in your plan |
| Other models | Anthropic's Claude, OpenAI's GPT, Google's Gemini, and others | Charged at the provider's API price against your included usage |
This split matters in practice. If you do most of your everyday work with Composer, your included usage goes much further. Save the Other models for the tasks where you specifically want them.
You can see how much you have used in your Cursor dashboard.
Plans
Cursor has a free Hobby tier (which includes access to Composer), a paid individual plan starting at $20 per month, higher individual tiers for heavy use, and Teams and Enterprise plans. Pricing and limits change, so check cursor.com/pricing for current details.
A Practical Model Selection Strategy
Rather than trying to pick the perfect model every time, a simple strategy works well for most developers.
Start with Auto or Composer
For most coding tasks (writing functions, fixing bugs, answering questions, reviewing code), Composer or Auto gives good results at good speed. Composer draws from the Cursor models pool, so it makes your usage last longest. Auto is billed at the price of whichever model it picks, so set it to Balance or Cost if you want it to stretch your usage. Make one of them your default and do not overthink it.
Upgrade for Hard Problems
When you hit a genuinely hard problem, such as a subtle bug you cannot find, a tricky algorithm, or a big refactoring decision, switch to a top frontier model or set Auto to Intelligence. The better reasoning is worth the wait and cost here.
Use Thinking Models for Logic-Heavy Work
If the task means working through constraints step by step (a complex algorithm, a data structure, business logic with many edge cases), pick a thinking or reasoning variant. They are slower, but for this class of problem they are noticeably better.
Pair Strong Models with Plan Mode
For large changes, use a capable model in Plan mode to research and write the plan. Then build from the plan with Composer or a faster model. You get careful thinking where it matters and speed for the edits.
Consider Context Size
If you need the model to hold a very large amount of code at once, choose a model with a large context window. For most tasks, any current model's context is plenty, especially since Agent searches the codebase and pulls in only what it needs.
Leave Tab Alone
Tab completion picks its own model. Nothing to configure.
Summary
Cursor gives you access to many models and lets you switch at any time from the picker in the chat input, or with Cmd+/. Think in categories rather than version numbers: Auto (with Intelligence, Balance, and Cost settings), Composer as Cursor's own coding model, and frontier models from Anthropic, OpenAI, Google, and others. Usage is split into a Cursor models pool, which goes much further, and an Other models pool charged at API prices. A simple strategy works: default to Auto or Composer, upgrade to a stronger or thinking model for hard problems, and let Tab handle itself.
Key Takeaways
- Model lineups change often, so learn the categories rather than specific version numbers
- Auto routes each request to a model and can be set to Intelligence, Balance, or Cost
- Composer is Cursor's own coding model, not a separate panel
- Switch models from the picker in the chat input, or press Cmd+/ to cycle models
- Cursor models (like Composer) come with much more included usage; Other models (Claude, GPT, Gemini) are charged at API prices
- Default to Auto or Composer, upgrade to a stronger or thinking model for hard problems, and pair strong models with Plan mode for big changes
- Tab completion uses Cursor's own Tab model automatically