Demo Choosing Models

In this lesson we cover how to choose and switch models in Cursor, the meaning of each mode (Ask, Agent, Edit, Thinking), and practical considerations like cost and external API keys. Use this guide to quickly pick the right model and workflow for code help, debugging, or multi-step tool use. Overview of Cursor UI and modes

Mode	What it does	Best for
Ask	Direct question-and-answer interactions — concise explanations, code snippets, or short guidance.	Quick debugging, straightforward questions, or Stack Overflow–style answers.
Agent	Enables multi-step tool usage and action orchestration (the model can call tools, perform steps, and manage workflows).	Automating tasks that require multiple actions or external tools.
Edit	Focused editing mode that modifies selected code or text (targeted refactors or revisions).	Rewriting code blocks, applying patches, or inline edits.
Thinking	Produces chain-of-thought reasoning or step-by-step explanations showing how the model arrived at an answer.	Understanding complex logic, debugging non-obvious behavior, or auditing reasoning.

Auto-select vs manual selection

Auto-select: Cursor chooses a model to balance speed, cost, and capability automatically. Good for general use when you want sensible defaults.
Manual selection: Turn off Auto-select to pin a specific model for consistent, deterministic behavior or to compare outputs between models.

Common model choices (examples you may see) Note: pricing and availability vary by provider and plan. The line below was shown in the source content: $0.05 per request and per tool use

Model	Typical capability / role
`claude-3.5-sonnet`	Solid mid-tier assistant for general-purpose help.
`claude-3.7-sonnet`	Higher-capacity model for improved reasoning and quality.
`claude-3.7-sonnet MAX`	MAX thinking variant: stronger chain-of-thought and internal reasoning.
`gpt-4o`	Powerful general-purpose model (good balance of capability and latency).
`cursor-small`	Lightweight, low-latency model for quick edits and scaffolding.
`gpt-4o-mini`	Cost-efficient model for many small interactions or bulk editing tasks.

What “Thinking” means

Traditional LLM response: The model gives a concise final answer or solution.
Thinking model: The model includes internal reasoning or chain-of-thought (step-by-step explanation of how it reached the answer).
Trade-offs: Thinking outputs are often longer, slower, and may cost more because they produce more tokens and internal processing.

Practical tips for choosing models

Use smaller, cheaper models (e.g., cursor-small, gpt-4o-mini) for:
- Scaffolding, boilerplate generation, and many quick edits.
- High-throughput tasks where cost matters.
Use mid-tier models (gpt-4o, claude-3.5-sonnet) for:
- Reliable, general-purpose assistance and balanced cost/quality.
Use MAX or larger thinking models (claude-3.7-sonnet MAX) for:
- Deep reasoning, complex debugging, or when you need a second opinion on critical decisions.
When unsure, try the same prompt across multiple models to compare phrasing, reasoning, or edge-case behavior. Generative outputs are not deterministic and different backends may provide useful alternative perspectives.

Model performance, latency, and pricing vary across backends. Higher-capacity models and requests that include tool usage or Thinking-mode reasoning can be significantly more expensive per request. If you expect sustained heavy usage, evaluate model costs against your budget before enabling costly defaults.

Using external API keys (OpenAI, Anthropic, Azure)

Cursor supports configuring external API keys to route requests through your own accounts (e.g., OpenAI, Anthropic, Azure). Billing will be according to the external provider’s rates.
Use external keys if you need:
- Centralized company billing or audit trails.
- Access to provider-specific models not directly enabled by Cursor.
Caveats:
- Some Cursor features (custom integrations, certain tool hooks) may not work the same way when using external keys.
- Costs can exceed Cursor Pro pricing depending on the external provider and model choices.

Example local terminal prompt you might see while working locally

(venv) jeremy@MACSTUDIO KodeKloudTaskManager %

Testing example (Python) This test example shows a simple Flask test client setup and a few tests that verify redirection and registration behavior.

def client():
    with app.test_client() as client:
        with app.app_context():
            init_db()
        yield client

    os.close(db_fd)
    os.unlink(app.config['DATABASE'])


def test_index_redirect(client):
    """Test that the index page redirects to login."""
    response = client.get('/')
    assert response.status_code == 302
    assert '/login' in response.headers['Location']


def test_register(client):
    """Test user registration."""
    response = client.post('/register', data={
        'username': 'testuser',
        'password': 'testpass'
    }, follow_redirects=True)
    assert response.status_code == 200
    assert b'Account created successfully!' in response.data

Using Ask vs Thinking in practice

Ask:
- Fast, concise, and usually cheaper.
- Example use: “What does def test_index_redirect do?” — returns a short explanation and key lines.
Thinking:
- Shows the model’s reasoning path, often very helpful for debugging or understanding subtle logic.
- Example use: When tests intermittently fail or logic is non-obvious and you want a step-by-step diagnostic.

A brief plain-language example (ELI5) for def test_index_redirect(client):

The test opens the homepage at '/'. The app is expected to send the visitor to the login page '/login'.
The test verifies that this redirection happens by checking:
- The response status code is 302 (a redirect), and
- The Location header includes '/login'.

Final recommendation Experiment with multiple models and modes to find the best balance of speed, cost, and quality for your workflow:

For fast scaffolding and repetitive edits, favor smaller models to save time and money.
For complex reasoning, use a Thinking model or a higher-capacity model as a second opinion.
If cost control and centralized billing matter, consider configuring external API keys but verify feature compatibility and pricing.

Links and references

Introduction to Cursor

Mastering Autocompletion

Interacting with your Codebase

Inline Editing and Debugging

Terminal Productivity

Understanding and Customizing Cursor

Demo Choosing Models

Watch Video