Microsoft had a busy day yesterday. November 17, 2026 — Ignite, San Francisco, Satya Nadella on stage — and the company shipped not one but seven new AI models in a single keynote. Most of them you can safely ignore for now. Two of them you can’t, because they live inside the tool your developers already use every day: GitHub Copilot.
Here’s the short version. MAI Code 2 is Microsoft’s new flagship coding model, built for the hard work — taking code to production, deep debugging, multi-file implementation. MAI Code 2 Flash is the fast, cheap one: explanations, targeted edits, routine fixes, the stuff you do fifty times a day. Both went generally available in Copilot the same day they were announced. And Microsoft’s headline claim is the kind that makes you stop scrolling: Code 2 delivers 96% of Claude Opus 5.5’s coding performance at 5% of the cost.
That number deserves a closer look before anyone switches a team over to it. I spent the morning reading Microsoft’s Ignite announcement, cross-checking the prices against GitHub Copilot’s pricing, and reading the secondary coverage from OrcaRouter and AI Press Box. What follows is the founder’s version: what it costs, what the numbers really mean, where the promo price ends, and the four-step playbook I’d follow before routing a single repo through these models.
One thing before we start. Every benchmark in this article is Microsoft’s own number. I’ll say that every time it matters, because vendor benchmarks are marketing with a spreadsheet attached. The prices, though — those I checked against GitHub’s own pricing page, and they’re real. The catch is that the prices you’re looking at today aren’t the prices you’ll pay in May.




What actually launched yesterday
Two models, one release, two very different jobs. MAI Code 2 is the flagship — Microsoft’s first in-house coding model aimed squarely at the frontier, built for what the company calls “taking code to production”: deep debugging, multi-file implementation, repo-wide reasoning, and UI work. MAI Code 2 Flash is the high-volume sibling: same family, much smaller, built for speed and for the routine work that makes up most of a developer’s day.
Both models were generally available in GitHub Copilot on day one — in the model picker and in Copilot Fusion, Microsoft’s multi-model agent setup. Code 2 Flash also landed in limited-access preview in Microsoft Foundry, through an OpenAI-compatible Responses API, which matters if you want to call it from your own backend. Code 2 itself has no Foundry deployment at launch — Copilot is the only way in for now. That’s a real constraint if your product calls models directly: you can route through Flash via API, but the flagship stays inside Copilot until Microsoft opens it up.
The spec sheet, from Microsoft’s published model card: Code 2 is roughly 2.8 trillion total parameters with 77 billion active per token; Flash is about 398 billion total with 12 billion active. Both trained on roughly 50 trillion tokens, with a knowledge cutoff of August 2026. The context window is listed as 128K in LiteLLM’s GitHub Copilot model table — that’s LiteLLM’s number, not Microsoft’s own, so take it as a working figure rather than gospel. For a startup, the practical translation is simple: these are big, serious models, and Flash is the small fast one that costs a tenth as much to run.
So where does this sit in the family? If you’ve been following Microsoft’s in-house models, MAI Code 2 is the successor to MAI-Code-1.1-Flash — the model we covered in our earlier guide — and that older model now has a retirement date, which we’ll get to below. The pace here is worth pausing on: Microsoft, OpenAI, and Anthropic have all shipped flagship models within days of each other this month. If your product roadmap assumes the model underneath it stays still for a year, that assumption is dead. Plan for a new model every quarter, and build your prompts and evals so swapping models is a config change, not a project.
The price table, translated into founder money
Real talk: per-token prices are the least useful number in AI pricing, and also the only number anyone publishes. So let’s do both — the table, then what it means for an actual job. And read the dates in this section twice, because they change everything.
GitHub Copilot rates, per million tokens, at the 50% promotional price that runs until 17 May 2027:
- MAI Code 2: $0.50 input, $0.025 cached input, $2.50 output — then $1.00 / $0.05 / $5.00 from 17 May 2027
- MAI Code 2 Flash: $0.05 input, $0.005 cached input, $0.25 output — then $0.10 / $0.01 / $0.50 from 17 May 2027
For scale, the rivals: Claude Opus 5.5 costs $4 per million input tokens and $20 per million output; GPT-6.1 Sol costs $2 in and $10 out. Per token, Code 2 is 12.5% of Opus 5.5’s price today — and 25% from May 2027, when the promo ends. Flash is 1.25% of Opus 5.5’s price today. Those are silly-cheap numbers, and they’re real. The question is what they mean per finished job, which is the only number that pays rent.
Now the worked example, because this is the number that should drive your decision. Say a job sends a 100,000-token prompt and gets a 5,000-token answer back, with half the prompt served from cache:
- Code 2, promo price: 50K fresh input at $0.50 per million ($0.025) + 50K cached at $0.025 per million ($0.00125) + 5K output at $2.50 per million ($0.0125) = about $0.04
- Code 2, full price from May 2027: 50K fresh at $1.00 ($0.05) + 50K cached at $0.05 ($0.0025) + 5K output at $5.00 ($0.025) = about $0.08
- Flash, promo price: 50K fresh at $0.05 ($0.0025) + 50K cached at $0.005 ($0.00025) + 5K output at $0.25 ($0.00125) = about $0.004
- Flash, full price from May 2027: 50K fresh at $0.10 ($0.005) + 50K cached at $0.01 ($0.0005) + 5K output at $0.50 ($0.0025) = about $0.008
Four cents for a serious coding job. Less than half a cent for the same job on Flash. And here’s the comparison that puts the promo price in perspective: the same job with no cache on Claude Opus 5.5 costs about $0.50 — 100K input at $4 per million ($0.40) plus 5K output at $20 per million ($0.10). Code 2 at promo price does it for about $0.06 without cache. That’s 12.5% of Opus 5.5’s per-token cost — exactly the figure I quoted above.
So why does Microsoft’s headline say 5% of the cost, not 12.5%? Because the headline is per-task cost, not per-token price. Per-task cost bakes in how many tokens each model actually uses to finish a job — retries, thinking tokens, output length. Microsoft’s claim is that Code 2 finishes coding tasks using so few tokens, at such a low price per token, that the total bill lands at 5% of Opus 5.5’s. Same logic on the other headline: Microsoft claims 98% of GPT-6.1 Sol’s coding performance at 40% of the cost, while the raw per-token math puts Code 2’s promo price at just 25% of Sol’s. The per-task figure is higher than the per-token figure there, which suggests Sol finishes some jobs with fewer tokens. Honestly? Both directions are plausible, and that’s exactly why you should treat the headline as a claim to test, not a fact to budget on.
The one thing I’d actually budget on is the doubling date. On 17 May 2027, both models’ prices double. Code 2 goes from $0.50 to $1.00 per million input tokens; Flash from $0.05 to $0.10. That’s still cheap — Code 2 at full price is still a quarter of Opus 5.5 per token — but if you build your cost model on today’s prices and forget the cliff, your May invoice will surprise you. Budget on the full price. Treat the promo as a discount, not the real cost.
The 96% claim — reading Microsoft’s numbers honestly
Look, I need to be straight with you about this section. Every number below comes from Microsoft. Not from an independent lab, not from a peer-reviewed paper — from the company selling the models. That doesn’t make the numbers fake. It makes them a starting point, not a verdict. Treat them the way you’d treat a startup’s own pitch deck: useful, directional, and worth verifying against your own work before you bet money on them.
MAI Code 2 delivers 96% of Claude Opus 5.5’s coding performance at 5% of the cost — and 98% of GPT-6.1 Sol’s at 40% of the cost. — Microsoft, announcing MAI Code 2 at Ignite 2026
With that caveat nailed to the wall, here’s what Microsoft claims. The two headline figures are averaged over four coding benchmarks: DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas, and FrontierCode v1.1. Those are real, recognized tests — SWE-style benchmarks measure whether a model can actually fix bugs and implement features in real repositories, and Terminal Bench tests whether it can do real work in a terminal. Averaging across four of them is better than cherry-picking one. But averaging is also a choice: a model can be weak on one test and strong on three, and the average hides the weak spot. Which test is Code 2 weakest on? Microsoft hasn’t said, and that’s the question I’d want answered before routing production work through it.
And the cost figures in that headline are shown at the 50% promotional price. That’s the part that matters most. “96% of the performance at 5% of the cost” is a promo-price claim. At full price from May 2027, the same per-token math would put Code 2 at roughly 10% of Opus 5.5’s per-task cost, not 5% — still a striking number, but a different headline. Microsoft’s own materials show the cost figures at the promo price, and the coverage has been clear about that. I’m flagging it here because it’s the single most important piece of fine print in this whole release, and it’s the kind of detail that gets lost by the third retelling.
There’s a second pattern worth noticing. The Ignite family has more of these claims, and they follow the same shape. Microsoft says MAI Cyber 2 Flash — the defensive-security model in the same launch — beats GPT-6 Astra on CyberGymE2E at under 2% of the cost per task. Impressive, until you read that 92 of the 905 tasks in that test were excluded for training-data overlap. Excluding tasks that overlap with training data is the right thing to do, honestly — it’s what a careful team should do. But it also means the comparison ran on 813 tasks, not 905, and the headline doesn’t say that out loud. Same lesson, same shape: read the exclusion note, not just the headline.

Code 2 vs Flash vs the rivals
No model launches in a vacuum, and this one lands in the middle of the busiest model week of the year. OpenAI shipped GPT-6.2 Astra and Sol on the same day — November 17 — and Anthropic’s Claude Fable 5.2 landed just nine days earlier. Microsoft is clearly aiming at both of them, and the pricing tells you how. Here’s the honest comparison, with the vendor claims labelled as vendor claims.
Against Claude Opus 5.5: the headline fight
Opus 5.5 is the model Microsoft is measuring itself against, and for good reason — it’s the coding flagship most serious teams compare everything to. Microsoft’s claim: 96% of Opus 5.5’s coding performance at 5% of the cost per task, averaged over those four benchmarks. The per-token math backs up the direction, if not the exact number: Code 2 at promo price is 12.5% of Opus 5.5 per token, and Microsoft says the per-task gap is wider still because Code 2 uses fewer tokens to finish a job.
Is 96% close enough? For most startup work, yes — with a caveat. The 4% gap concentrates in the hardest tasks: the multi-file refactors, the gnarly debugging sessions, the jobs where the model has to hold a whole repo in its head. If your work is mostly that kind of job, the 4% matters and the price saving doesn’t. If your work is the normal mix — features, fixes, tests, reviews — 96% at a fraction of the price is a trade any founder should take seriously. Our Claude Fable 5.2 founder’s guide covers the other side of this fight, and it’s worth reading alongside this one before you pick a side.
Against GPT-6.1 Sol: the awkward one for OpenAI
Here’s the number that should make every founder pause. Microsoft claims Code 2 delivers 98% of GPT-6.1 Sol’s coding performance at 40% of the cost. Sol is OpenAI’s efficient everyday model — the one that, in our GPT-6.2 Astra and Sol founder’s guide, came within half a point of the flagship Astra on real-world coding at a fifth of the price. And now Microsoft is saying its flagship coder nearly matches Sol at less than half Sol’s cost per task.
Read that again. Microsoft’s flagship coding model claims to nearly match OpenAI’s cheap everyday model — and the story is the price, not the performance. The raw per-token math is even friendlier to Microsoft than the headline: Code 2 at promo price is $0.50 in and $2.50 out per million tokens, against Sol’s $2 in and $10 out. That’s 25% on both. So the 40% per-task figure actually suggests Sol finishes jobs with fewer tokens than Code 2 does, which eats into the price advantage. Either way, the direction is clear: if you’re choosing a coding model on cost per finished task, Code 2 is now in the same conversation as Sol, and Flash — at a tenth of Code 2’s price — is cheaper than both.
Flash vs everything: the volume play
Flash is the model most founders will actually end up using most, and Microsoft knows it. At $0.05 per million input tokens and $0.25 per million output — promo price — it’s priced for volume: code explanations, targeted edits, routine fixes, rapid iteration. The jobs where you call the model fifty times a day and never think about it. At those prices, the cost of a single Flash call is so small that the decision isn’t really about money anymore — it’s about whether Flash is good enough for the job, and whether your routing sends easy work to Flash automatically instead of letting it drift to the expensive model by default.
One honest gap: Microsoft hasn’t published a headline benchmark number for Flash the way it has for Code 2. The Flash story is told in prices and use cases, not in benchmark tables. That’s fine — Flash isn’t competing on benchmark scores, it’s competing on being cheap enough to use everywhere. But it does mean you’re flying a bit blind on Flash’s actual quality until you test it on your own work. Which brings us to the playbook.
Where you can actually use them (and where you can’t)
This is the part that trips people up, so let me be very clear. Both models are generally available in GitHub Copilot right now — in the model picker and in Copilot Fusion. If your team already uses Copilot, switching is a dropdown change, not a migration project. That’s the good news, and it’s genuinely good news: the last few model generations have trained founders to expect a week of plumbing work with every release, and this one doesn’t ask for it.
The plan breakdown matters, though, because the two models don’t ship on the same plans — check GitHub’s Copilot plans page for the current details:
- MAI Code 2 is on Copilot Pro ($10/month), Pro+ ($39), Max ($100), Business ($19 per user per month), and Enterprise ($39 per user per month) — for eligible annual-plan subscribers.
- Code 2 Flash is on every plan, including Free and Student.
That split is deliberate. Flash is the on-ramp: anyone can try it, including free users and students, which is how Microsoft gets a generation of developers used to its models before they ever pay. Code 2 is the paid tier’s reward. For a startup, the practical question is which plan your team is already on. If you’re on Pro, you get both models plus $15 in AI credits ($10 base plus $5 flex). Pro+ includes $70 in credits; Max includes $200; Business includes 1,900 credits; Enterprise includes 3,900. Check your plan before you promise the team a new model — a Free-tier developer can use Flash today but won’t see Code 2 in the picker at all.
And then there’s the API question. Code 2 Flash is in limited-access preview in Microsoft Foundry through an OpenAI-compatible Responses API, which means you can call it from your own backend with minimal integration work if you get access. Code 2 itself has no Foundry deployment at launch — Copilot only. If your product calls models directly rather than through Copilot, Flash is your route in for now, and Code 2 is a wait-and-see. That’s a real limitation for teams building AI features into their own products, and it’s worth knowing before you plan a roadmap around the flagship.
One more practical note. If you’re already using Copilot, the switch is a model-picker change — but the routing is what decides your bill. Set Flash as the default and switch to Code 2 only for the hard jobs. Defaults decide spending more than any pricing page does. And if your team ships a lot of code through AI, this is also the moment to get systematic about reviewing what comes back — we wrote a whole guide on the best AI code review tools for small teams, and it applies directly here: cheaper models mean more AI-written code, and more AI-written code means review matters more, not less.
What each model is actually good at
Benchmarks aside, what do these models do differently in your hands? Microsoft built Code 2 for the deep work: taking code to production, deep debugging, multi-file implementation, repo-wide reasoning, and UI work. That’s the job list of a senior engineer, not a autocomplete tool. The test that matters is whether it can hold a whole feature in its head — the files, the tests, the edge cases — and ship something that passes review without three rounds of fixes. Microsoft’s benchmark claims say it can, at least on the tests they ran. Your repo is the test that counts.
Flash, meanwhile, is the workhorse. Code explanations when a new hire is reading an unfamiliar codebase. Targeted edits — fix this function, rename that variable, add this test. Routine fixes and rapid iteration, the loop you run twenty times before lunch. When the model is this cheap, the right question stops being “can I afford to call it?” and starts being “am I calling it enough?” — for the small stuff, at least. The failure mode to watch is the opposite one: reaching for the flagship out of habit when Flash would have done the job for a tenth of the price.
And here’s where it connects to your business directly. If your product needs more than a clever prompt — a real website, real design work, AI wired into the product properly instead of bolted on — that’s the kind of build AISquadX does, and it’s worth getting a team that has shipped this stuff before rather than learning the hard lessons on your own launch timeline.
The retirement you need to plan for: MAI-Code-1.1-Flash leaves on 18 December 2026
Buried in the launch news is a date that matters more than most of the headlines. MAI-Code-1.1-Flash — the model our earlier guide covered, and the one some teams have already built routing around — retires from GitHub Copilot on 18 December 2026. That’s one month from launch. Not six months, not a year. One month.
If your team, your scripts, or your Copilot configuration reference MAI-Code-1.1-Flash by name, you need to move that routing to Code 2 Flash before December 18. The natural replacement is Code 2 Flash: same role in the family, faster, cheaper, and — by Microsoft’s framing — better. But don’t just swap the name and walk away. A model swap is a behavior change, even inside the same family. Run your common jobs through Code 2 Flash this week, compare the outputs to what 1.1-Flash gave you, and confirm the new model handles your edge cases before the old one disappears. A retirement deadline is the worst time to discover a behavior difference.
For most teams this is a small job — an afternoon, maybe less. But it’s the kind of small job that turns into a Monday-morning outage if nobody owns it. Put one person’s name on it this week.
The wider Ignite family, in brief
Code 2 and Flash were two of seven models Microsoft shipped at Ignite, and the rest of the family is worth a quick scan even if none of it changes your roadmap today. MAI Cyber 2 Flash is the defensive-security model — the one with the CyberGymE2E claim and the 92 excluded tasks I mentioned above. MAI Image 2.7 handles image generation, MAI Realtime 1 handles live voice and video, and MAI Transcribe 2 handles speech-to-text. Decision 1.1, the model for business decisions, is generally available with more than 4,000 customers already. And MAI Licensed Weights, offered through a new outfit called Frontier Co, is Microsoft’s route for customers who want to run model weights under license.
None of those seven is the story for a startup this week — Code 2 and Flash are, because they live in Copilot. But the shape of the launch tells you something about Microsoft’s direction: in-house models across every modality, priced to undercut the frontier labs, and shipped through the tools developers already use. The MAI family is a platform play, not a one-model bet. If you’re building on Microsoft’s stack, that matters. If you’re not, it’s still worth watching, because the pricing pressure from this launch will push everyone else’s prices down too.
The 4-step founder playbook
Enough theory. Here’s the sequence I’d follow this week, in order, and it takes about an afternoon.
- Pick the model by the job. Flash is the default for everything: explanations, targeted edits, routine fixes, rapid iteration. Code 2 is for the hard jobs — taking code to production, deep debugging, multi-file implementation, repo-wide reasoning. If the task needs deep thinking across many files, use Code 2. Everything else, Flash. Don’t pay ten times the price for easy work.
- Price the real cost per task, not per token. Run your five most common jobs through both models and measure the whole job: retries, thinking tokens, cached versus fresh input. The worked example above puts Code 2 at about $0.04 and Flash at about $0.004 for a typical job at promo prices — but your jobs are the only ones that count. And remember the cliff: both models double in price on 17 May 2027, so run the same math at full price and make sure the decision still holds.
- Switch it on in Copilot. Open the model picker and set Flash as your default, with Code 2 one click away for the hard jobs. Check your plan — Code 2 needs Pro or above, Flash is on every plan including Free. Move any MAI-Code-1.1-Flash routing to Code 2 Flash before it retires on 18 December 2026. Set a spend cap while you’re in there.
- Test it on your own work before switching production. Your messiest repo, your ugliest bug, your real feature request — not a demo prompt. Measure cost per finished task, not per token, and compare it against what Opus 5.5 or Sol costs you for the same job. Microsoft’s 96% claim is theirs. Your numbers are the ones that decide your stack. Then decide in one afternoon. Don’t debate it for a week.
Frequently asked questions
Is MAI Code 2 really 96% as good as Claude Opus 5.5 at 5% of the cost?
That’s Microsoft’s own claim, not an independent result — and it comes with two pieces of fine print. First, the 96% is averaged over four coding benchmarks (DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas, FrontierCode v1.1), so it hides which test Code 2 is weakest on. Second, the 5% cost figure is per-task cost at the 50% promotional price, which ends 17 May 2027. Per token, Code 2 is 12.5% of Opus 5.5’s price today, and 25% from May 2027. Still cheap — but not 5%. Test it on your own repo before you believe any of these numbers.
How much will MAI Code 2 cost after the promo price ends?
Both models double on 17 May 2027. Code 2 goes from $0.50 to $1.00 per million input tokens, $0.025 to $0.05 cached, and $2.50 to $5.00 output. Flash goes from $0.05 to $0.10 input, $0.005 to $0.01 cached, and $0.25 to $0.50 output. A typical job — 100K-token prompt, half cached, 5K-token answer — costs about $0.04 on Code 2 today and about $0.08 at full price; Flash costs about $0.004 today and about $0.008 at full price. Budget on the full price so May never surprises you.
Which Copilot plan do I need for MAI Code 2?
Code 2 is on Pro ($10/month), Pro+ ($39), Max ($100), Business ($19 per user per month), and Enterprise ($39 per user per month), for eligible annual-plan subscribers. Flash is on every plan, including Free and Student. Pro includes $15 in AI credits ($10 base plus $5 flex), Pro+ includes $70, Max includes $200, Business includes 1,900, and Enterprise includes 3,900. Both models are live in the Copilot model picker and Copilot Fusion right now.
What happens when MAI-Code-1.1-Flash retires?
MAI-Code-1.1-Flash leaves GitHub Copilot on 18 December 2026. If anything in your setup references it by name, move that routing to Code 2 Flash before then — same role in the family, faster and cheaper. Test the swap on your common jobs first, because a model change is a behavior change even inside the same family. Don’t wait until the week it disappears.
Should my startup switch from Claude or GPT to MAI Code 2?
Not on the headline alone. Code 2’s pricing is genuinely aggressive — 12.5% of Opus 5.5 per token today, 25% of GPT-6.1 Sol per token — and Microsoft’s own benchmarks put it close to both on coding. But the benchmarks are Microsoft’s, the cost headline is at promo price, and switching costs are real: prompts, evals, tooling, and your team’s habits all assume the current model. Run your five most common jobs through Code 2 and Flash this week, measure cost per finished task, and compare against what you’re paying now. If the numbers hold on your work, switch. If they don’t, the promo price will still be there in January.
The Bottom Line
MAI Code 2 is a good release, and the most interesting thing about it isn’t the flagship. It’s that the cheap model got so cheap that the flagship has to justify itself job by job. Flash costs a tenth of Code 2 per token and handles the routine work most developers do all day. Code 2 nearly matches Claude Opus 5.5 on Microsoft’s own tests at a fraction of the price — and even at full price from May 2027, it’s still a quarter of Opus per token. That changes the default. Flash first, Code 2 when the job is genuinely hard — that’s the whole strategy in one sentence.
But keep your eyes open. Every benchmark that makes Code 2 look dominant comes from Microsoft, the cost headline is priced at a promo rate that doubles in May, the flagship isn’t available through the Foundry API yet, and the model you may already be using — MAI-Code-1.1-Flash — disappears on December 18. None of that is a reason to wait. It’s a reason to test on your own work, measure cost per finished task, budget on the full price, and move your routing before the retirement date.
The models are live now, in Copilot’s model picker, for free users on Flash and Pro subscribers on Code 2. An afternoon of testing will tell you more than any launch post — including this one. Go run your ugliest real bug through Flash, your hardest real feature through Code 2, and let the numbers decide.



