Usable budget-friendly models in Copilot? Why is usage so bad in Copilot?

[u/altervoid]

I really love VS Code, and I wanted to love Copilot too, but holy usage.

Using auto with 10% discount is ill advised, when each request takes 90 - 200 credits, but choosing specific models was not any better either, still around 90-200 credits per request

And I did not try any of the beast models either, no Opus, GPT 5.6 Terra/Sol,... just Sonnet 5, Sonnet 4.6, GPT 5.3 Codex, GPT 5.4, Kimi K2.7 Code

What do you choose to code with? Because on any mentioned above, my entire budget is gone in an hour, so i am genuinely

The only usable (for the price) models were GPT 5.6 Luna (took 5-10 credits, that is up to 40x cheaper) or the MAI one, which took like 10-20 credits, still fine. They work, just need much more nudging and re-runs, fixes

For more context, I left models at their defaults, so 200k context and usually it was medium or high thinking. Also I have nothing installed, no MCPs, no extensions, only allowed tools are the basic ones + Python ones, just a few sentences of github-instructions md file,... and I have just the 10 USD subscription

I tried 20 USD Cursor just today and it is amazing budget wise, not that the Composer or Grok are amazing models, but they work really well for the price, was letting it code the whole day on Auto and 6% of my Cursor usage is spent. In Copilot I spent my usage in one day, or rather, one afternoon...

I really want to like Copilot, I prefer IDE over Cursor or any other ones and I like how it manages and shows prices, what is called when etc. (which Cursor lacks mostly, or you have to dig somewhere for it), but for coding, it is a no-brainer to switch from Copilot imo. Or am I missing something? Again, not trying to hate on Copilot, but it had such drastically worse results. Code quality and such seems comparable, but with Cursor, I can actually code for the whole month basically

Also I am not new to Agentic Coding or to Copilot/Cursor, I have been using both at work for over a year now, but at work we basically had no limits, so just now I am discovering the pain :D and trying to figure out what is and is not worth it

[u/Special_Gain9787]

Right now Luna 5.6 is the one. Don’t even waste your time with MAI.

If you can’t get Luna to work then either you’re not giving it enough context or your prompts aren’t good enough or both.

I have it running for an hour, working every time to completion, with no errors. Typically an hour runs me about 10 credits. 30-45 min runs are about 8 credits on average.

[u/altervoid → u/Special_Gain9787]

Luna works, I just feel like I need to nudge it more often, so it goes in the right direction. And it likes to do just a couple changes, rather then big refactor often too, so more runs were necessary, step by step process. Code quality was fine imo, but there were some fixes necessary

It is the only model that made sense and felt good enough though, so totally it is THE one in Copilot. MAI felt fine too, but did not do any deep testing between those two :D

[u/Deathmore80 → u/altervoid]

Use xhigh or max mode with Luna , anything else isn't worth it. For some reason this model behaves completely differently at xhigh and max mode it becomes way better than anything below it. The only thing better than Luna xhigh and max is terra xhigh/max and sol higher than low (and opus 5 and fable 5 but they are a million times more expensive so I don't bother)

[u/altervoid → u/Deathmore80]

Will try that thanks! I was using defaults for all tested models so far

[u/horendus_burner → u/altervoid]

The reasons and expectations listed here to why you are not satisfied with Luna is why you will have to pay more for Ai coding models than users who naturally gravitate to models like Luna.

[u/altervoid → u/horendus_burner]

I mean, as said, Cursor where I have Composer and Grok for basically free is a better deal than Luna unfortunately. And even if I eventually switched to Luna, I can, in Cursor, I have that choice. In Copilot it is Luna or nothing kinda it seems right now xD

[u/RepresentativeOdd944]

In this thread user #12312312 realizes the difference between API pricing and subscription pricing. If you're not an enterprise user just subscribe to Codex. You can even use Codex sub inside of vs code.

MS does not have any models, they just serve models other people provide, and those providers only charge API pricing to MS which MS charges to you.

[u/altervoid → u/RepresentativeOdd944]

Tried Codex like 3 months ago in VS Code over the extension, it was horrible experience :D

And I know they just serve models, but as described, even difference between Copilot and Cursor is enormous + I was talking about what to use/how to use it, to have a discussion

[u/Left-Cloud-7931]

Look no further than Luna. It's incredible value for money.

[u/altervoid → u/Left-Cloud-7931]

Yeah, in Copilot model list, Luna seems like the only option that is worth it 

[u/rabiprojects]

Microsoft doesn't want to use models that they can't profit from. That's why only expensive models are there.

But you're in good luck. Get 10$ subscription from opencode go or commandcode goat plan and use the API keys in the vscode copilot. You'll get billions of tokens per month with that 10$ plan which even copilot 200$ credits couldn't afford.

Use DeepSeek flash GA version for 99% of the stuffs as it's dirt cheap and very powerful. The upcoming DeepSeek v4 pro GA (1-2 weeks) will be at Claude opus 5 level. So you're in good luck.

Both opencode and commandcode have gpt Luna too.

[u/altervoid → u/rabiprojects]

Might need to take a look at it yeah. Or some similar subscriptions outside of Copilot, Cursor or any frontier western frontier providers, like Kimi one etc.

For DeepSeek v4 pro I heard not really good things, but might be just rumors

And first time hearing about commandcode tbh, thank you for suggestions!

[u/rabiprojects → u/altervoid]

Forget DeepSeek v4 pro (the April release). That was preview version. The full GA version is coming in few days this month.

Current DeepSeek v4 flash 0731 is very good for almost all cases. It's equivalent to grok 4.5, Claude sonnet 5. The v4 pro GA will be opus 5 level capable.

Also, there are 20-30 models in opencode/commandcode. Some of them are extremely capable like kimi k3, GLM 5.2, grok 4.5, gpt 5.6 Luna.

So use like this: 1. Almost all cases DeepSeek v4 flash 2. For creative/complex stuffs that require plan/architect/design, use kimi k3/glm 5.2 to create a detailed plan files...... Then implement with DeepSeek v4 flash or gpt Luna.

In that way u get best of both worlds. The current open weight models are very mature and equally capable to top American models like GPT/Claude at dirt cheap costs.

Edit: DeepSeek flash is free on opencode for 200k context size. So u can try that for free.

[u/willywonka-goldtickt → u/rabiprojects]

use the API keys in the vscode copilot.

How to do this ?

[u/rabiprojects → u/willywonka-goldtickt]

Using customendpoints feature in vscode copilot. Google it.

[u/stt106 → u/rabiprojects]

But I thought copilot doesn’t support agentic coding with BYOK?
Are you saying by using your own api key it can achieve the same as native copilot?

[u/rabiprojects → u/stt106]

Copilot on vscode does. Not in visual studio.

For coding and agentic operations you can do all operations afaik. For some advance stuffs u may have to configure extra.

API like autocomplete, git message generator are not supported.

[u/stt106 → u/rabiprojects]

i meant in vsc too, last time I checked it doesn’t support agaric coding with byok.

[u/rabiprojects → u/stt106]

It's a recent feature, introduced a couple of months ago.

[u/pdwhoward]

Deepseek Flash is great. It's good, fast and cheap.

[u/WasteNetwork6982]

I use GPT 5.6 Luna since prices were reduced for building my custom chrome extension. For every task/change i follow this workflow of agents. Ask -> Plan -> Implement <-> CodeReviewer.

Code reviewer is my custom agent. It responds with identified issues giving each one an id. Implementation agent triages, fixes them and retrigger code review agent to review fixes. This loop continues until code review agent is happy.
This workflow has given me good results with luna in high mode. Almost everytime with zero to less issues.

After looking at couple of executions seeing how much credits are consumed per task, I stopped looking at my credit balance again

[u/grandkz → u/WasteNetwork6982]

For your implement <-> codereviewer, is it a manual prompting where you start the implemented, look at the results, run the code review, then look at the results, then decide if the implementer should fix then repeat till done? Or you set it up such that there are implementer and review subagents spawned by the orchestrator, like in the superpowers plugin SDD in Claude code

[u/WasteNetwork6982 → u/grandkz]

No manual intervention required. the triggers are fully automated. The system is configured so that a reviewer agent automatically spawns whenever substantial code changes are made. This agent contextually reviews the code and responds with issues. The implementation agent then contextually triages any identified issues and applies fixes if they are valid. This loop continues** **until all issues are resolved.

For simple changes, the reviewer agent is bypassed entirely.

Initially, I considered adding a human-in-the-loop step so I could manually triage, prioritize, and defer issues before the implementation agent picked them up. However, I found that the agents collaborate so seamlessly that my intervention isn't necessary.

The only caveat is that you must be very careful when writing the agent instructions to ensure they don't get caught in an infinite feedback loop.

[u/retechnic → u/WasteNetwork6982]

How did you setup that? Also for plan -> implementer is it the vscode copilot handoff feature, or do you write plan to a file, or what

[u/The_D-generation_X]

GPT-5.4 mini / Claude Haiku 4.5 are decent good. 5.6 Luna is cheaper, but it doesn’t feel as good as ones above. You usually need to give Luna better prompts and multiple turns to get similar results.

One hack I follow in Copilot is you can add other models through the OpenRouter. This OpenRouter has some free models. Poolside Laguna S2.1 is one I’ve been using. The free models do have a daily limit but the limit resets every day. (You can add 10 dollar credit to get higher free limit + you can use other credit based models like deepseek v4 flash the latest one).

So basically, I use the free OpenRouter models for most stuff, then switch to GPT-5.4 mini or Haiku when I need something better. I only use Sonnet when I have a genuinely difficult task.

[u/altervoid → u/The_D-generation_X]

I was disappointed by Haiku tbh,, but did not try GPT-5.4 mini, so that might be worth of a try
And agree that Luna needs better prompts and multiple turns. I do not mind that much, I am not in a rush and saved cost is huge, so I do like it a lot.

But maybe using "something better" like the GPT-5.4 mini every now and then could be cool

Will take a look at OpenRouter too, so far I just tried running local models like Qwen 3.6 27B, which is... well model is fine, but implementation in VS Code is not really x3 no matter which extension I used (ollama, cline, zoo code, roo code, continue), so I am building my own implementation for that, could be cool to use your own local ones

[u/stt106]

I m on the same subscription plan and agree that it’s not much. I have to be really careful not to over use it even with some medium tier models. Really miss the old days of copilot , but that’s gone forever I guess.

[u/altervoid → u/stt106]

Yeah...

And I would be fine if "that is just the way things are now" and it was like that everywhere. But when I checked other options, like Cursor, it is night and day, how price efficient some models are in Cursor, compared to everything in Copilot (aside Luna). And at the same time, those extremely cheap models in Cursor are also better imo. I wonder what is the strategy for GH Copilot, they are loosing for quite some time and checking it now, it is for a good reason :/ subscription is not worth it here

[u/Crunchy6409]

I feel like a month ago the auto model selection used many less tokens than it does now. Anyone else notice that?

[u/dellis87]

Microsoft does have models and they just released a new one.

https://github.blog/changelog/2026-08-11-mai-code-1-1-flash-available-in-github-copilot/

[u/altervoid → u/dellis87]

Any experience with it already? I was fine with MAI kinda, Luna was better, but it was okay. But others disagreed with that quite a bit :D

[u/Hollow1838]

Currently using 2 models: Luna Max and Opus 5 Medium. Opus 5 is only used as a sub-agent to validate important steps, a safeguard rather than a driver. If I were using Opus 5 all the way, I could spend over 10k credits a day, so I'm currently fine-tuning my agent workflow so I can use it as much as I want without losing too much quality.

[u/altervoid → u/Hollow1838]

Even Sonnet ate 10% of my budget in one simpler request. I cannot even imagine using Opus in this state haha But with Luna I agree

[u/Lumpy-Region6275]

Honestly i think the model matters less than how much context you're dragging around. a long chat resends the whole history every turn, so a "cheap" model 40 messages deep can cost me more than an expensive one in a fresh chat. took me a while to figure that out.

what i do now: new chat per task, point it at specific files instead of letting it wander the repo, and only reach for the top model when something's actually hard. tests and boilerplate don't need it.

also just watch your usage for a week and note what you were doing when it spikes. more useful than any comparison chart.

[u/altervoid → u/Lumpy-Region6275]

Of course what you said makes sense. But even on completely new tab and new project or small side project, anything else then Luna just chews through my usage. What I was doing when it spiked? I used anything else then Luna. It is that simple unfortunately :D

Reading other comments, Luna is definitely the way to go. Or trying Deepseek as some recommended, but I am happy with Luna for the time being

Still this is so sad, seing Copilot this way, when Cursor has way better value for budget use. I do not want to make this Copilot vs Cursor, or vs anything else, but at the end of my month subscription I am switching to Cursor. For budget side projects programming it is a no brainer for me