Product feedback: cost opacity, routing, plans, Agents window (~1 year heavy use)

Ideas Feedback
, , ,
1

I’ve used Cursor heavily for most of a year on real apps (Rust, Flutter). I like it and plan to keep using it. The agent loop, multi-file edits, and IDE integration are genuinely strong.

Note: I’m not looking for support or workarounds (worktrees, settings toggles, etc.). This is product feedback: what’s confusing, what I avoid, and what would make me trust the product more. Take it or leave it; happy to clarify if useful.

Cost and model controls

  • Composer Fast is ~6x Standard token cost with the same intelligence. Fast is the default, often hidden under picker → hover Composer → Edit. I wasn’t in a hurry. I didn’t know I was on the expensive tier for a long time, and I only discovered this recently.
  • MAX / context / effort / model names are different axes, and critical options are buried under picker → hover model → Edit (e.g. on Opus: Context 300K vs 1M, Effort, Thinking, Fast). I missed the context swap for a long time because it’s not on the main picker. The global MAX toggle still exists, but it’s unclear what it does vs Edit → Context, vs Effort “Max”, vs models labeled “High”. The context meter doesn’t show which limit is actually active. On Composer, MAX seemed to change nothing useful.
  • Context is one bucket per chat. Summarize near the limit is lossy. New chat + handoff before ~150K works better than hoping MAX or a hidden 1M setting saves a full thread.

Model routing, Auto, and cost visibility

Choosing the right model and splitting work by phase is harder than it should be. Before each prompt I do a mini cost vs difficulty calculation. I even tried using AI to help route tasks, but that’s unreliable and burns tokens.

I avoid Auto today because I don’t know which model or cost tier it picks. It’s fine in principle, but I don’t want the product choosing models without me knowing. It should be transparent and editable: which model ran, which tier (Standard/Fast, effort), why it was picked, and an easy override. I’d go as far as showing cost per request (or a clear usage estimate) so I can learn what tasks actually cost instead of discovering it from a depleted pool.

The UI could help more upfront, e.g. “this looks like implementation / UI / architecture, suggested: Composer Standard, new chat, phase scope” with a rough cost tier, not just a model picker.

Longer term, routing more work to task-tuned or smaller models (UI wiring, refactors, boilerplate) instead of frontier generalists for everything might save everyone money. I don’t need Opus-level reasoning to nudge layout spacing; I do for security and architecture.

But smarter routing only helps if it’s visible, not another “trust me bro” Auto. Show what was suggested, why (task type + cost tier), which model would run, and let me confirm or override before it sends. Routing in the product beats doing cost/difficulty math in my head, as long as I’m not losing control of my code or my spend.

Plans, Build, and Multitask

Plans help, but phases blur when plans grow. Build = one chat for everything, so I hesitate on bigger features. Multitask: unclear when parallel is safe. I’d like parallel agents for speed, but I don’t know when they’ll conflict on the same files or WIP. I don’t want to break my codebase. Little guidance on isolation (worktrees? branches? independent tasks?). I run one phase = one chat until that’s obvious.

Agents window vs IDE chat

I still want control over my code, not “apply everything and hope it works.” IDE chat’s granular Keep/Undo per change matches how I review agent edits. The Agents window feels more file/git-level, so for anything non-trivial I stay in the IDE.

I’m not asking for a Claude Code-style terminal-only workflow; that doesn’t fit how I work. I’d rather you improve the existing chat + editor flow (diff review, confidence before accept). A detachable (pop-out) agent panel could be nice: same review model, more layout flexibility, without replacing the IDE.

Also small UX nit: the Agents window entry point feels oversized, like the product is nudging me toward a mode I don’t trust yet for careful edits. Less billboard, more optional.

Wishes (not a how-to ask)

  • Cost + model transparency: Standard vs Fast with cost shown; per-request usage estimate; Auto that discloses model + tier with confirm/override; document what MAX does vs Edit → Context
  • Context + workflow: meter labeled per model and active settings; MAX grayed when irrelevant; plans → build this phase only in fresh context; clear rules for safe parallel agents
  • IDE-first review: keep granular Keep/Undo; optional pop-out chat, not a separate review model I don’t trust

Cost opacity has been stressful. I kept paying premium by accident while trying to be careful. I still plan to use Cursor; clearer defaults and visible routing would restore a lot of trust. Thanks for reading.

6

Follow-up on the new model picker

Quick clarification, since the picker layout changed after this feedback and a lot of the discussion elsewhere is “rollback.”

I asked for effort / context / Fast to stop being buried under hover → Edit. That part is better now: those knobs are visible, and killing the old MAX confusion helps.

What I did not ask for is burying the model list behind a submenu. Model switching got worse for mouse use. I still change models often (e.g. plan on one model, implement on another), so an extra click/hover every switch is real friction. Surfacing options should not mean demoting the model picker.

Please don’t full-revert. Putting everything back behind a tiny Edit button would undo the useful half. The old hierarchy was closer to right (model first, settings second) — settings were just too hard to discover. Prefer:

  1. Model dropdown — searchable list (type-to-search, recent models). Primary: choose who is answering.
  2. Settings dropdown — Thinking / Context / Effort / Fast. Secondary: tune the selected model. Effort stays a setting, not duplicate rows in the model list.

Chip/label should always show the model name (optionally with effort), not effort alone.

Same idea as “choose the agent, then tune it” — not “tune parameters, then dig for the agent.”

…Still open from the original post (still more important for trust than layout):

  • Fast vs Standard cost visible…
  • Auto that shows which model + tier ran…

Update: I now handle model/phase routing myself outside Cursor (rules + handoff prompts) and that works well for me. Auto disclosure would still help others who don’t.

I still like Cursor and plan to keep using it. This is just: keep the knobs visible, restore fast model switching on the mouse path, clear model labeling, and make cost/routing less opaque. Happy to clarify further if useful.