A customer asked us a fair question. Cursor’s Composer 2.5 is cheap and fast. Opus 5.5 is strong and expensive. Why not use Composer for the routine parts of a coding session and switch to Opus when the work gets hard?
So we tried it. We took a 20-turn coding session from real work on our own services and ran it in Cursor three ways: Composer on every turn, Composer on 12 routine turns with Opus 5.5 on the 8 hard ones, and Composer on the routine turns with Cursor Auto on the hard ones. We picked the hard turns the way a careful engineer would: the investigation at the start, the production incident in the middle and the final audit.
Mixing helped, but much less than you’d expect, and it cost more than people assume.
| Setup | Score | Cost per session | Savings vs Opus 5.5 | Minutes |
|---|---|---|---|---|
| ModelOpus 5.5, every turn | 90% | $43.37 | baseline | 112 |
| GovernorQuality mode | 89% | $30.73 | 29% | 102 |
| ModelSonnet 5.5, every turn | 87% | $39.22 | 10% | 110 |
| GovernorBalanced mode | 87% | $24.70 | 43% | 76 |
| GovernorCost mode | 83% | $8.80 | 80% | 65 |
| CursorComposer 2.5 on easy turns + Opus 5.5 on hard turns | 75% | $18.51 | 57% | 46 |
| CursorComposer 2.5 on easy turns + Cursor Auto on hard turns | 71% | $17.51 | 60% | 42 |
| CursorComposer 2.5, every turn | 63% | $4.90 | 89% | 38 |
Composer plus Opus got to 75%. Governor’s Cost mode scored 83% for less than half the money. Balanced mode matched Sonnet at 87% for $24.70, under what Sonnet costs for the same session.
The easy turns weren’t easy
Here’s what surprised us. The hard turns went fine. When Opus handled the investigation, it scored the same as Opus running the whole session, about 90%. The points were lost on the turns everyone would call routine.
| Routine turn, handled by Composer in the mix | Composer in the mix vs Opus every turn |
|---|---|
| Write the implementation plan | 70%89% |
| Run the test suites, record a baseline | 62%88% |
| Implement the fix | 60%89% |
| Handle a requirement change from product | 36%86% |
| Respond to a code reviewer | 73%93% |
| Re-run the tests, compare with the baseline | 56%90% |
| Write the pull request descriptions | 55%91% |
| Write the on-call runbook | 80%93% |
Composer, mixed sessionOpus 5.5, every turn
What these turns have in common is that each depends on something established earlier in the session. The model has to remember a baseline from eight turns back, or carry a race condition found in the investigation into the code it writes.
That’s where Composer slipped, and the judge’s notes are specific about it. When asked to re-run the tests and compare against the baseline, Composer compared against the wrong snapshot. It called a failing check “new” when that check had been failing since the start, and it reported the bot’s tests as unchanged when 13 had been added. On the requirement change it said one of the two services needed no change at all, missing a status update that could overwrite the user’s answer. On the implementation turn it said a five-second limit was met while an awaited update still ran on a retrying client that could hold the answer far longer.
None of that was hidden. The baseline it should have used was sitting earlier in the same conversation, and the code was right there in the repo. The answers read fine, which makes this worse: you’d ship them.
So “use the cheap model for the easy stuff” falls apart in agentic work, because late-session work is rarely easy in the way it looks. Writing a PR description is simple. Writing a correct one for a change made across two services over twenty turns isn’t.
Every switch back to Opus re-buys the conversation
The second problem is cost, and it’s easy to miss.
Model providers cache the conversation so each new request only pays full price for what’s new. That cache belongs to one model. When the session moved from Composer back to Opus, Opus had to write the whole conversation into its cache again. When Opus followed Opus in these sessions, it usually wrote 25,000 to 60,000 new tokens to its cache. On the turns right after a Composer stretch it wrote 140,000 to 350,000.
In dollars, those rewrites came to about $5 to $5.50 of each $17 to $20 session, roughly 30% of the bill. Composer’s side of the switch is close to free. The expense lands every time you switch back to the expensive model, which is exactly when you wanted it.
Cursor Auto made this a little worse. On the hard turns it moved between Opus 5.5, GPT-5.6 Terra, Sonnet 5 and Grok 4.7, so there were more switches, and it scored lower than handing those turns to Opus.
What works instead
The Governor settings in the table don’t swap models mid-session. Balanced mode keeps Opus for the whole session and lowers how hard it thinks, with written guidance on how to work: read the code before changing it, cover every part of the request, check instead of assuming. Cost mode runs Haiku 5.5 the same way. The cache stays warm, nothing gets re-bought, and every turn is handled by a model that can carry the whole session.
That’s why Cost mode beats a Composer and Opus mix by 8 points at half the price. One capable model with good guidance does better than a cheap model that drops context with an expensive one standing by.
How we tested
The session is 20 turns on two real services: investigate a production slowdown, prove the cause by experiment, plan, implement, test, handle a requirement change and code review, fix a follow-up incident, then write PR descriptions, a runbook and a final audit. Every answer was graded against an answer key checked against the code, by a judge scoring five dimensions. The judge is Claude Opus 5.5, and the answer keys tie it to facts rather than taste. We ran two sessions per setup. Session-to-session spread was 1 to 2 points.
Costs are what each session cost, as charged by Cursor or the model provider.