AI AI Tools Guidebook
Troubleshooting

Cursor Auto Model Picks Weak Model for Hard Task

Cursor's Auto model router routes a complex refactor to a small model, producing shallow or wrong edits. Diagnose routing signals and force the right model for hard tasks.

Published: Author: AI Productivity Guide Team 🌐 查看中文版本

You hand Composer a non-trivial task: refactor an auth flow, propagate a type change across 30 files, design a migration. With the model picker set to “Auto”, you get back a shallow patch that fixes two files, misses the rest, and confidently declares the work done. Switch to Sonnet 4.6 or Opus 4.7 manually and the same prompt produces a thorough multi-file change set. Auto is optimizing for cost and latency on signals it can see (prompt length, file count, keywords) — it cannot see your intent. The fix is partly configuration, partly prompt hygiene, and partly knowing when not to use Auto at all.

Common causes

Ordered by likelihood for under-routing.

1. Prompt too short for the actual scope

Auto reads prompt length as a complexity proxy. “Refactor auth to use JWT” is 35 characters. The router sees a tiny request and picks a fast model — even though the work behind those 35 chars is enormous.

How to spot it: Your prompt is one line, the task spans many files, the result is shallow. Long, explicit prompts trigger heavier models reliably.

2. No files attached to the chat context

When the @-context is empty, Auto assumes a generic question. It routes to a small model. Even if your prompt is long, no context = “probably a Q&A turn”.

How to spot it: The chat side panel shows zero attached files / folders / docs. Composer’s “Working with” line is empty.

3. Fast Requests quota is healthy and biases toward small models

If your Fast Request quota is high (early in the billing cycle), Auto leans toward the cheap, fast model because it can afford to. As you exhaust quota, it sometimes upgrades — counterintuitively, you may get better routing later in the month.

How to spot it: Same prompt produces a noticeably better answer in the second half of the month, or after Cursor: Reset Fast Requests was NOT done.

4. Task type doesn’t match Auto’s routing heuristics

Auto’s heuristics are tuned for common patterns: small inline edits, single-file Q&A, simple completions. Tasks like “write a migration”, “design an interface”, “plan an architecture” don’t fit those shapes and get under-routed.

How to spot it: The task is design-heavy or cross-file but phrased like a casual question. The output is plausible-sounding but lacks depth.

5. Chat history pollution biases routing

Auto can use chat history as a signal. If the last 5 turns were trivial (“add a log line”, “rename this var”), the next request inherits that “this is a small-task session” prior — even if your new prompt is huge.

How to spot it: Starting a fresh chat with the exact same prompt produces a better answer than re-using a long-running session.

6. Codebase indexing not complete

If indexing is still running or stale, @codebase context is thin. Auto sees a small effective context and routes down. See Cursor indexing never completes.

How to spot it: Status bar shows indexing in progress, or @codebase returns very few hits for a known-good query.

Before you start

  • Note which model Auto actually picked — hover the response or check the model badge under the assistant turn.
  • Note your Fast Request balance (Settings -> General -> Usage).
  • Confirm indexing is complete and the workspace is the one you think it is.
  • Save the prompt text — you will rerun it with explicit model selection.

Information to collect

  • The exact prompt text.
  • Files / folders / docs attached as context.
  • Auto’s chosen model (shown under the assistant message).
  • Whether this is a new chat or continuation of a long session.
  • Your subscription tier (Free, Pro, Business) — routing pools differ.
  • Time of month relative to billing cycle reset.

Step-by-step fix

Ordered fastest to most thorough.

Step 1: Switch the model picker off Auto for hard tasks

The lowest-effort fix:

Composer model dropdown -> Sonnet 4.6 (or Opus 4.7 for design / planning)

Auto is a good default for “fix this typo” or “explain this function”. It is the wrong default for “refactor”, “design”, “migrate”, “plan”, or anything cross-file. Build a habit: hard verb in the prompt -> manual model.

Step 2: Expand the prompt and attach context explicitly

A vague prompt with no context routes down. Reframe:

Refactor src/auth/* from session cookies to JWT.
@src/auth @src/middleware @docs/auth-design.md

Constraints:
- Keep the public API (login, logout, refresh) unchanged
- Update tests in src/auth/__tests__/
- Use jose for signing, not jsonwebtoken
- Migration plan for existing session DB rows

Produce a step-by-step plan first, then execute.

Length + attached folders + structured constraints all push Auto toward heavier models. Even on Auto, this often gets you the right routing.

Step 3: Start a fresh chat for major tasks

Long chats inherit prior-turn bias. For anything serious:

Cmd+N (or Cmd+L) -> new Composer chat

Paste the big prompt into the clean context. The router scores it on its own merits.

Step 4: Set a workspace-level model preference for engineering chats

Add to .cursor/settings.json or workspace settings:

{
  "cursor.composer.defaultModel": "claude-sonnet-4.6",
  "cursor.chat.defaultModel": "claude-sonnet-4.6"
}

This pins per project, so the auth refactor repo gets Sonnet by default while a docs repo can stay on Auto.

Step 5: Two-pass it — plan with a strong model, execute with Auto

For long executions you want to be cheap, use the strong model to draft a detailed plan, then hand the plan to Auto:

Pass 1 (Opus 4.7):
Produce a detailed step-by-step plan for the JWT migration. List every file to
touch and the diff intent for each. Do not execute yet.

Pass 2 (Auto):
Execute the plan from the previous message exactly. Do not reorder steps.
For each step, edit the named file and report back.

The plan substitutes for the routing signal Auto could not infer.

Step 6: If routing remains wrong, file telemetry feedback

Cursor’s Auto router uses session telemetry to improve. After a bad routing decision:

Composer message -> "..." menu -> "This was the wrong model"

This feedback loop adjusts routing for similar future prompts in your account.

Verify

  • Re-run the same prompt with Sonnet 4.6 forced — output is deeper than Auto’s was.
  • Run a clearly trivial prompt (“rename foo to bar in this file”) with Auto — it picks a fast model and is correct. Auto is not broken; it is calibrated for small tasks.
  • Cross-file refactors with explicit context and a workspace-pinned default model now consistently engage the strong model.

Long-term prevention

  • Default to manual model selection for Composer in engineering repos; reserve Auto for chat-style Q&A.
  • Write longer, more specific prompts even when you “know what you mean” — the router does not.
  • Always attach @folder or @codebase context for cross-file tasks.
  • Use a two-pass plan-then-execute pattern for big migrations.
  • Audit your Fast Request usage monthly so quota state is not a hidden routing variable.
  • Keep a shortcut snippet (“hard task template”) that pre-attaches structure and constraints.

Common pitfalls

  • Believing “Auto means best model available”. Auto means “cheapest model the router thinks will work”. Those are different optimizations.
  • Re-running the bad prompt unchanged hoping for a different result — same inputs, same routing.
  • Setting cursor.composer.defaultModel in user settings only — it leaks across projects. Prefer workspace settings.
  • Mixing trivial and serious work in one chat session. The trivial turns bias the heavy one.
  • Forgetting that codebase indexing depth affects routing. Stale index = thinner context = weaker routing.
  • Burning through Opus 4.7 on tasks Sonnet 4.6 handles equally well, then having no quota for the hard task that actually needs it.

FAQ

Q: Can I force Auto to always pick a strong model?

Not directly — Auto is the router. But pinning cursor.composer.defaultModel to your preferred strong model effectively bypasses it.

Q: Why does Auto route differently for the same prompt on different days?

Quota state, model availability, and aggregate routing telemetry all change daily. Auto is not deterministic.

Q: Does longer prompt = always better routing?

Length is one signal. Specificity, attached context, and presence of “design”, “refactor”, “plan” verbs matter more. A 500-character vague prompt routes worse than a 200-character precise one.

Q: Should I just always use Opus 4.7?

No — Opus is rate-limited and burns Fast Requests fast. Match model to task. Sonnet 4.6 is the workhorse for most cross-file work; Opus 4.7 for novel design or genuinely hard reasoning.

Tags: #Cursor #Troubleshooting #Composer large project #AI coding

Related Articles