For seven years, the most widely used AI product Microsoft sells ran on somebody else's model. This month it stops.
Project Polaris — Microsoft's own coding model, announced at Build on June 2 — becomes the default engine for every GitHub Copilot subscriber in August, replacing OpenAI's GPT-4 Turbo. Existing subscribers are migrated automatically. There is no announcement banner to dismiss, no setting to accept. The autocomplete suggestion that appears in your editor next week comes from a different model than the one that appeared last week, and for most of the roughly 4.7 million people paying for Copilot, that is the entire user-facing experience of the change.
Microsoft has been careful to say what this is not. Polaris is a default, not an exclusive. OpenAI's models remain selectable inside Copilot, alongside other third-party options. Teams that want to stay on GPT-4 Turbo get a three-month fallback window to opt out while they test their integrations.
That framing is accurate and it is also, in practice, a rounding error. Defaults are the product. The share of developers who will open a model picker, evaluate alternatives and deliberately switch back is small, and everyone shipping software knows it — which is why the default was worth building a model to win.
What Actually Changes
| Element | Before | From August 2026 |
|---|---|---|
| Default Copilot engine | OpenAI GPT-4 Turbo | Microsoft Project Polaris |
| Migration | — | Automatic for existing subscribers |
| Staying on GPT-4 Turbo | Default behaviour | Opt-out, three-month window |
| Inference hardware | OpenAI models on Azure | Microsoft Maia accelerators, exclusively |
| Who gets paid for inference | OpenAI | Microsoft |
| Third-party models | Selectable | Still selectable |
Architecturally, Polaris is a mixture-of-experts model with specialised sub-modules tuned for different programming languages, frameworks and paradigms — rather than one general model asked to be equally good at everything. It carries a context window reported at around 100,000 lines of code, which is the scale at which a model can hold a real service in its head rather than a file.
Microsoft's benchmark claim is that Polaris outperforms GPT-4 Turbo on HumanEval and MBPP across most languages, with the strongest margins in lower-resource languages like Rust and Haskell, where training data is scarce and model quality shows. The Rust and Haskell detail is the credible part: those are exactly the languages where a general-purpose model trained mostly on Python and JavaScript tends to fall apart, and where per-language specialisation should help most.
The Real Story Is the Silicon
Polaris runs exclusively on Maia, Microsoft's own AI accelerators, inside Azure. That single sentence is the business case for the entire project.
Microsoft has been paying OpenAI for model access since its 2019 investment. Every Copilot completion — across 4.7 million paid subscribers and roughly 77,000 enterprise customers — was inference Microsoft bought from a supplier and resold at a margin set partly by that supplier. Polaris on Maia collapses the stack: Microsoft's model, on Microsoft's chips, in Microsoft's cloud, inside Microsoft's product. The margin that used to leave the building stays in it.
The hardware arrived first. Microsoft unveiled Maia 200 on January 26, 2026, an accelerator built specifically for inference rather than training — over 10 petaFLOPS at 4-bit precision, more than 5 petaFLOPS at 8-bit, and a claimed 30% better performance per dollar than its previous generation of AI silicon. It is already running in Microsoft data centres in Des Moines, Iowa and Phoenix, Arizona.
Read the two announcements together and the sequencing is obvious: build the cheap inference chip in January, announce the model that runs on it in June, make it the default in August. This was not an opportunistic swap. It was a supply chain being assembled in public, one piece at a time.
Why This Month, and Not Last Year
The timing is not a coincidence either. On April 27, 2026, Microsoft and OpenAI restructured the partnership that had defined both companies since 2019. Microsoft's licence to OpenAI's intellectual property became non-exclusive, running through 2032. OpenAI won the right to sell its products on any cloud, including Microsoft's direct competitors. Microsoft stopped paying revenue share on OpenAI products it resells through Azure.
Microsoft remains OpenAI's primary cloud partner, and OpenAI products still ship first on Azure in most cases. But exclusivity had already become unenforceable. OpenAI's compute demands had outgrown what Microsoft could supply; it had signed into the $500 billion Stargate data centre project with Oracle and SoftBank, and in February 2026 announced a strategic partnership with Amazon worth up to $50 billion — an arrangement structurally incompatible with the old terms.
So both companies stopped pretending. OpenAI got to sell everywhere. Microsoft got to stop paying for a dependency it had spent two years engineering its way out of. Polaris shipping as the Copilot default three months later is the first visible consequence of that divorce, and the clearest signal of what Microsoft intends to do with its freedom: compete on model quality, not just distribution.
What It Means for the People Using It
Copilot is not a side project. Microsoft reported roughly 4.7 million paid subscribers on its FY26 Q2 earnings call in January — paid subscriptions up about 75% year over year — with around 90% of the Fortune 100 using the assistant in some form, and an estimated 42% share of the paid AI coding tool market. Independent estimates put annual recurring revenue somewhere between $850 million and $1.1 billion.
For an individual developer, the practical questions are narrow and worth answering now rather than in November. Does Polaris handle your language well, or is your stack outside the set Microsoft optimised for? Do your prompts, custom instructions and agent workflows behave the same? Did anything in your CI pipeline quietly depend on the old model's output shape?
Enterprises have a harder version of the same problem, because their answer has a deadline attached. The fallback window is three months. After it closes, the model in the loop is Microsoft's — and the compliance review, the security assessment and the vendor documentation all point at a model that has no public system card, no independent evaluation, and a benchmark sheet written by the company selling it.
What to Take From This
- Vertical integration is the strategy, not the model. Own model, own chip, own cloud, own product. Polaris matters less as a technical artefact than as the moment Microsoft stopped renting the most important component of its biggest AI business.
- "Still selectable" is doing heavy lifting. OpenAI's models remain available in Copilot. Almost nobody will pick them. Default placement inside a product with millions of paying seats is worth more than any benchmark.
- The benchmark baseline is the tell. A 2026 model beating GPT-4 Turbo on HumanEval and MBPP is a floor, not a ceiling. Until there is a SWE-bench number or third-party evaluation, treat the performance claim as unverified.
- Three months is short for an enterprise. Any team with model-specific tooling, prompt libraries or compliance sign-off has a real migration on its hands, and the clock started in August.
- OpenAI just lost its largest distribution channel by default. Not by being outcompeted on quality — by being designed out of a product it used to power, by the company that resold it.
The Takeaway
Microsoft spent seven years building the most successful AI developer product on the market using a model it did not own, on economics it did not fully control. In January it shipped the chip. In June it announced the model. In August it flipped the default, automatically, for 4.7 million paying subscribers.
Whether Polaris is actually better is genuinely unresolved. The evidence offered so far is a comparison against a model from 2023 on benchmarks the field has largely outgrown, published by the vendor, with no system card and no independent evaluation. The Rust and Haskell results suggest the per-language specialisation is doing something real. That is not the same as proof.
But the question of whether it is better is separable from the question of whether it wins, and only one of them was ever in doubt. It is the default now. That was always the point.