# Feature Request: User-configurable model routing rules for the main agent

[1777 (17)]

Feature request for product/service

AI Models

Describe the request

Feature Request: User-configurable model routing rules for the main agent

Problem

Currently, model routing in Cursor works at two levels:

1. Auto mode — Cursor internally routes to different models, but it’s opaque, not user-configurable, and optimizes for reliability/speed rather than user-specific workflow needs.
2. Sub-agent (Task tool) — Users can specify a model parameter per sub-agent via rules, which works great for delegation.

However, there’s no mechanism for rule-based model routing at the main agent level within a single conversation. Users must either:

• Manually select a model before starting a conversation (losing context if they guess wrong)
• Stay locked to one model for the entire session (overpaying for simple tasks, or under-powering complex ones)
• Use reasoning models (e.g., Opus 4.6 High) which lock the conversation entirely

Use Case

I’m a product manager using Cursor as my primary work environment. A typical session involves:

1. Direction-setting (architecture design, strategy alignment) — needs frontier reasoning (Opus-class)
2. Execution (writing docs from established structure, research synthesis, batch edits) — a mid-tier model (Grok 4.5, Sonnet) handles this well at lower cost
3. Housekeeping (file operations, formatting, log updates) — a fast/cheap model suffices

Today, I handle this via sub-agent delegation with model-specific rules. But for context-heavy tasks (which represent 70%+ of product work), delegating to a sub-agent means duplicating the full conversation context in the prompt — which can actually increase cost rather than save it.

Proposed Solution

Allow users to define model routing rules (via .cursor/rules/ or settings) that the main agent respects mid-conversation. For example:

# .cursor/rules/model-routing.mdc
routing:
  - task_type: "architecture_design, strategy, complex_reasoning"
    model: "claude-4.6-opus-high-thinking"
  - task_type: "document_writing, research_synthesis, code_review"
    model: "cursor-grok-4.5-high-fast"
  - task_type: "file_operations, formatting, simple_search"
    model: "composer-2.5-fast"

The agent would:

Classify the current turn's task type (lightweight classifier, similar to how Auto already works)
Check against user-defined routing rules
Switch to the appropriate model while preserving full conversation context
Why This Is Different from Auto
Auto optimizes for Cursor's cost/reliability — users can't influence the routing logic
This proposal lets power users define their own quality/cost tradeoffs based on their specific workflow
Context continuity is preserved (unlike sub-agent delegation which duplicates context)
Key Technical Consideration
The main challenge is reasoning model state (e.g., Opus High generates reasoning traces that other models can't consume). A practical middle ground: allow switching between models within the same "reasoning family" (e.g., Opus High ↔ Sonnet High), or implement a "context summary + handoff" mechanism when crossing reasoning boundaries.

Impact
This would make Cursor significantly more cost-effective for power users who run long, multi-phase sessions — without sacrificing the context continuity that makes single-conversation workflows valuable.