Native "Fusion / Sidekick" Mode for Agent (Lead Architect + Fast Executor Runtime)

Feature request for product/service

AI Models

Describe the request

The Problem
In Cursor’s current Agent and Composer workflows, a single model handles the entire lifecycle: high-level architecture, multi-file planning, brute-force file rewriting, linter execution, and syntax cleanup.

  • Frontier models (e.g., Claude Fable 5.1, GPT-6 Astra) are overkill and expensive for churning out mechanical boilerplate or streaming massive diffs.

  • Fast execution models (e.g., Composer 2.5, Grok 4.6) are cheap and fast at editing files, but prone to architectural drift, subtle logic regressions, and context blindness on complex refactors.

While users currently attempt a manual workaround (having Model A write a plan and Model B execute it), that static waterfall breaks the moment real-world execution begins.

The Proposal: Lead + Sidekick Dual-Runtime
Introduce a native dual-model execution mode (inspired by Devin’s Fusion architecture) directly selectable in the Agent model picker:

  • Lead (Architect / Supervisor): Frontier reasoning model responsible for indexing context, designing the execution path, reviewing diffs, and diagnosing unexpected runtime failures.

  • Sidekick (Executor / Worker): High-throughput, cost-efficient model dedicated strictly to generating diffs, running terminal commands, applying boilerplate, and processing routine linter passes.

Why a Dynamic Feedback Loop Beats Static “Agent-to-Agent” Planning
A real supervisor loop is fundamentally different from just splitting chats:

  • Active Supervision over One-Way Handoff: The Lead doesn’t just produce a static TODO.md and vanish; it monitors the execution cycle state-by-state.

  • Automatic Escalation on Regressions: If the Sidekick encounters breaking test outputs, missing dependencies, or API mismatches, control immediately escalates back to the Lead for structural recovery instead of having the smaller model hallucinate fixes.

  • Sanitized Context Windows: The Lead’s context remains completely clean, free from noisy compiler logs, massive raw diffs, and formatting artifacts. Only structured state transitions and architectural context reach the Lead.

  • Zero Friction: No manual prompt copying, no managing separate chat windows, and no custom sub-agent orchestration needed from the user.

Benefits for the Cursor Platform

  • Massive Token & Cost Savings: Cuts down high-tier token consumption on large codebases while maintaining frontier-grade quality.

  • Faster Throughput: Fast models stream code and diffs at double the speed without user-facing latency.

  • Higher Task Completion Rates: Combines frontier-tier system design with aggressive, high-speed execution loops.

Screenshot / Screen Recording

Feature request for product/service

Cursor CLI

Describe the request

Hi Cursor team and community,

I’m a long-time Cursor user and rely on it daily for planning, coding, debugging, and shipping. Agent has become a core part of my workflow.

I’d love to see a Fusion Mode: let users configure a main/planner model and an executor model separately, so we can get strong results without burning through quota as quickly.

The idea
Many Agent tasks naturally split into two phases:

Planning — understand intent, break down the task, design the approach, make key decisions
Execution — write code, edit files, run commands, handle mechanical follow-through
Right now, using the strongest model end-to-end is often overkill for the execution phase and consumes quota fast. Using a lighter model end-to-end can weaken planning quality on harder tasks.

Fusion Mode would solve this by letting us assign models by role:

Main / Planner model: stronger reasoning for understanding, planning, and review
Executor model: more cost-efficient model for implementing the plan
Suggested behavior
Toggle Fusion Mode in settings
Separately choose:
Planner model
Executor model
Default flow:
Planner designs the approach
Executor implements it
Planner reviews critical checkpoints / final result
Optional: auto-fallback to a single model for simple tasks, so we don’t add unnecessary overhead
Usage dashboard should show planner vs. executor consumption separately, so users can tune the setup
Why this would help
Better quota efficiency — spend premium tokens where they matter most
Better quality — keep strong models for planning/review
More control — power users can optimize cost vs. quality for their own workflows
Clearer product differentiation — controllable cost + high-quality Agent feels very “Cursor”
Example configs
Complex refactor / architecture work:
Planner = strongest reasoning model, Executor = strong coding model
Routine feature implementation:
Planner = mid-tier model, Executor = cheaper/faster model
Simple edits:
Single-model mode only
Ask
Would the team consider adding something like Fusion Mode (or an equivalent dual-model Agent workflow)?

Happy to join a beta and share real workflow feedback if this goes into testing.

Thanks for building Cursor — this would make heavy daily usage meaningfully more efficient.