Project Polaris is Microsoft’s in-house AI coding model, unveiled at Microsoft Build 2026 (June 2, 2026) as the future reasoning engine for GitHub Copilot. Starting August 2026, Polaris replaces GPT-4 Turbo as the default model for Copilot subscribers, with automatic migration and an optional three-month fallback period for teams that want to stay on GPT-4 through the transition. The architecture is mixture-of-experts, with specialized sub-modules tuned for different programming languages and frameworks. Microsoft says Polaris outperforms GPT-4 Turbo on the standard HumanEval and MBPP benchmarks, with particular gains in lower-resource languages like Rust and Haskell. Pro tier subscribers also get expanded capabilities: multi-file context up to 100,000 lines, and autonomous test generation that produces and runs test cases without a developer in the loop. The model runs on Microsoft’s custom Maia AI accelerators inside Azure, which Microsoft says reduces per-inference latency and lowers cost.
The bigger story behind the announcement is the relationship arc with OpenAI. Microsoft and OpenAI ended their seven-year exclusive partnership in April 2026. Polaris is the first major signal that Microsoft intends to compete on model quality, not just on distribution. This post covers what Polaris actually is, what the benchmark claims mean, the Pro tier capabilities that change the developer workflow, the Maia hardware angle, the strategic context, the August 2026 migration path, and what teams using GitHub Copilot should be doing between now and the automatic migration.
What Project Polaris actually is
Polaris is a mixture-of-experts (MoE) architecture. In an MoE model, the network has many specialized expert sub-networks, and a routing layer decides which expert to activate for any given input. The active-parameter count for any single inference is smaller than the total parameter count, which keeps per-inference cost manageable while letting the model specialize across very different task domains.
Microsoft’s specific MoE design for Polaris pairs the architecture with domain specialization that maps cleanly to coding: separate expert sub-modules tuned for different programming languages and frameworks. The benefit is most visible in the languages where general-purpose code models tend to underperform because their training data is thinner. Rust and Haskell are the two languages Microsoft singled out at Build, both of which present the same training-data problem (less code on the open web than Python or JavaScript) and benefit substantially from a model with explicit specialization for them.
The position in Microsoft’s broader model family is worth holding clearly. Polaris is the coding-specific reasoning engine. It’s a sibling to (not a replacement for) the rest of Microsoft’s MAI (Microsoft AI) suite, which also got significant updates at Build 2026: MAI-Image-2.5 for image generation and editing, MAI-Voice-2 for multilingual text-to-speech with expanded emotional range, and MAI-Transcribe-1.5 for transcription. Together with Polaris, the MAI v2 suite is what Microsoft is positioning as its alternative to the OpenAI stack across text, image, voice, and transcription.
What the benchmark claims actually mean
Microsoft’s positioning at Build was that Polaris outperforms GPT-4 Turbo on HumanEval and MBPP. These are the two most-cited code-generation benchmarks in the industry. A quick definition for context:
HumanEval is OpenAI’s coding benchmark: 164 hand-written Python programming problems, each with a function signature, docstring, body, and unit tests. A model is scored by the percentage of problems it solves correctly. Standard benchmark; widely reported.
MBPP is "Mostly Basic Python Problems," Google’s coding benchmark: 974 short Python tasks of varying difficulty. Each task includes natural-language description, code solution, and unit tests. Same scoring shape; broader coverage than HumanEval.
A model that outperforms GPT-4 Turbo on both benchmarks is a credible Python-coding model. The "particular gains in low-resource languages like Rust and Haskell" framing is where the MoE specialization shows its value: those gains would not show up in either HumanEval or MBPP (both Python-only), so Microsoft is signaling that the benefits extend beyond the benchmark suites. The honest read is that the benchmark numbers establish Polaris is at least as good as the GPT-4 Turbo baseline for general coding, with additional gains in the languages MoE specialization helps most.
Microsoft has not published full numerical scores from the Build announcement (or those scores haven’t been independently verified yet). The claims are vendor-published positioning. Treat them as directional rather than authoritative until third-party benchmarks land.
Pro tier: 100,000-line context and autonomous test generation
Two Pro tier capabilities are the most consequential workflow changes Polaris introduces.
Multi-file context up to 100,000 lines. GPT-4 Turbo’s context handling in GitHub Copilot has been per-file or limited multi-file. Polaris extending Pro tier context to 100,000 lines means the model can reason across a substantial chunk of a real codebase in a single inference, rather than having context fed to it piecemeal through retrieval. The practical effect: refactoring tasks that span many files, debugging sessions that need cross-file traces, and "explain this codebase to me" requests all work cleanly in a way they didn’t before. Cross-file changes that previously required either careful prompting or a custom retrieval setup now happen natively.
Autonomous test generation. Polaris Pro can generate tests for code under development and run those tests itself, without a developer in the loop. The capability fits the broader industry shift from "AI suggests, developer reviews" to "AI executes, developer verifies the result." The work pattern this enables: an engineer writes a function, Polaris generates the test suite for it (including edge cases and adversarial inputs), runs the tests, reports the results back. If tests fail, the engineer sees the failures and the proposed code change; if tests pass, the engineer reviews the function plus the tests as one unit.
The natural comparison for autonomous test generation is Anthropic’s Dynamic Workflows in Claude Code, which we covered as part of our Claude Opus 4.8 launch coverage. Both products are converging on the same conclusion: AI that writes code should be able to verify code without handing off the verification step to a separate human review. The implementations differ; the direction is the same.
The Maia AI accelerator angle
The infrastructure side of Polaris matters because it’s where Microsoft’s economic story differs from the OpenAI-as-a-service model.
Polaris runs on Microsoft’s custom Maia AI accelerators inside Azure. Maia is Microsoft’s in-house AI silicon (announced in November 2023, scaling through 2024-2026), positioned as the company’s answer to NVIDIA’s H100/H200 dominance for AI training and inference workloads. Microsoft says running Polaris on Maia reduces per-inference latency and lowers cost relative to running an equivalent workload on third-party hardware.
The reduced-cost claim is the strategic point. When Microsoft was paying OpenAI per Copilot inference, the cost structure was OpenAI’s API pricing, and the margin was OpenAI’s to capture. With Polaris on Maia, Microsoft owns both the model and the silicon, captures the full margin, and can price Copilot’s underlying inference cost wherever it wants relative to the per-developer subscription revenue. The Polaris-on-Maia combination is vertical integration of the developer-AI stack, with the cost transparency that vertical integration enables.
For Copilot subscribers, the Maia hardware is invisible. The migration to Polaris doesn’t change how you call the API or what your IDE shows you. The infrastructure shift matters because it determines what Microsoft can do with pricing, capacity, and feature pace over the next few years; it doesn’t change anything the developer touches.
Why Microsoft built its own: the OpenAI partnership context
The Polaris announcement reads cleanly only when you read it against the partnership timeline.
Microsoft and OpenAI signed their first major partnership in 2019, with Microsoft investing $1 billion in OpenAI and securing exclusive cloud infrastructure rights. The partnership scaled through 2020-2024 (the additional $10 billion investment in January 2023; the Bing integration; Copilot itself launching as a GPT-4-powered product). It started cracking publicly in 2025 as OpenAI’s commercial ambitions and Microsoft’s product ambitions began competing in the same markets. In April 2026, after months of negotiation, the seven-year exclusive partnership officially ended. Microsoft retained an equity stake and a continued commercial relationship; the exclusivity, the data-sharing terms, and the model-co-development terms all changed.
Polaris is the first public artifact of what Microsoft has been building in the background during the latter years of that partnership. The bet inside Microsoft, judging from the model’s positioning, is that the coding-tools market is large enough and strategic enough that owning the model is worth the engineering investment. The downstream effect is that GitHub Copilot becomes a fully vertically integrated product: Microsoft owns the IDE plugin, the editor (VS Code), the cloud (Azure), the AI hardware (Maia), and now the model (Polaris). No other coding-AI product in 2026 has that depth of integration.
For context on the broader AI coding-tools landscape, our Claude Code vs OpenAI Codex comparison covers two of the major competitors to GitHub Copilot, and our Google Antigravity overview covers Google’s vertically-integrated competitor (which similarly owns the model, hardware, IDE, and cloud).
The August 2026 migration path
Microsoft’s published migration timeline has three parts.
Automatic migration starting August 2026. All GitHub Copilot subscribers (Individual, Business, Enterprise) move to Polaris as the default model on a rolling basis through August. No action required from the developer; the model swap is invisible at the API and IDE-extension surface.
Optional three-month fallback. Teams that want to stay on GPT-4 Turbo through the transition window can opt in to the fallback. Microsoft hasn’t published the exact opt-in mechanism, but the framing suggests it’s a tenant-level setting for Business and Enterprise plans rather than a per-developer choice. The fallback runs three months from migration date, presumably ending around late October or early November 2026 for the earliest migrants.
Post-fallback behavior. After the three-month window, GPT-4 Turbo is no longer available as a Copilot default. Teams that built workflows specifically tuned to GPT-4 Turbo behavior need to migrate those workflows to Polaris by end of the fallback window.
The pattern matches how Microsoft has handled previous Copilot model migrations (the GPT-3.5 → GPT-4 transition followed a similar opt-in fallback model in 2023-2024). For most teams, the right action is to let the automatic migration happen and adapt prompts and workflows as needed in the natural course of using Polaris.
What this means for the developer-tools landscape
Three broader implications worth flagging.
The coding-tools market is now a multi-vendor model race. Through 2024-2025, GitHub Copilot was effectively a GPT-4-powered product competing against Claude Code (Anthropic’s stack), Cursor (initially Claude/GPT-4, increasingly multi-model), Cody (Sourcegraph + multi-model), and the various other entrants. With Polaris, that competitive landscape now has GitHub Copilot powered by Microsoft’s own model, not by a third-party. The model layer becomes part of the differentiation rather than something all the major products share. For background on this broader competitive picture, our AI agents pillar covers the agentic coding-tools category more generally.
Microsoft is signaling independence from OpenAI is feasible. A year ago, the conventional wisdom was that the deep partnership with OpenAI meant Microsoft couldn’t really compete with OpenAI’s models even if it wanted to. Polaris (plus the MAI v2 suite) demonstrates that’s not true. Whether Polaris ends up being as good as the next generation of OpenAI’s models is a separate question, but the architectural and operational independence is real. That changes how you read every subsequent Microsoft AI announcement: the company is building toward not depending on OpenAI rather than toward extending the OpenAI relationship.
Vertical integration is becoming the dominant strategic pattern. Microsoft’s stack (Polaris + Maia + Azure + VS Code + GitHub) and Google’s stack (Gemini + TPU + Google Cloud + Antigravity + Android Studio) are both vertically integrated AI-developer-tools plays. Anthropic’s stack is less vertically integrated by choice (Claude on AWS / Google Cloud / their own infra; Claude Code as the developer tool; no proprietary silicon). OpenAI’s stack runs on Microsoft Azure for now but is increasingly building toward its own infrastructure. The pattern that’s emerging: each major AI lab that’s also a major developer-tools vendor is investing in owning the full stack rather than partnering across vendors. The strategic case for that is clear (margin capture, capability differentiation, supply security); whether the operational case holds at all of these companies remains to be seen.
What teams using GitHub Copilot should do before August
A few practical takeaways for development teams between now and the migration:
- If your team uses GitHub Copilot for routine code completion and the workflow doesn’t depend on specific GPT-4 Turbo behaviors, the migration is essentially free. Let it happen automatically in August. Test the first few weeks of Polaris-default behavior against your usual prompts to confirm the upgrade pattern; expect minor adjustment for some prompts but no major workflow rewrites.
- If your team uses Copilot SDK to build internal tooling, evaluate Polaris during the preview window if Microsoft opens one. The SDK behavior under Polaris will shape any custom Copilot integrations you maintain. The August automatic migration applies to your SDK callers too.
- If your codebase has substantial Rust, Haskell, or other lower-resource languages, Polaris is positioned to be an improvement on day one. The benchmark gains in those languages are where MoE specialization helps most. Plan to retest your Copilot-assisted workflows in those languages after migration; the quality lift may be substantial.
- If you’ve been building agent-style workflows on top of Copilot (automatic PR reviews, test generation, multi-file refactoring), the Pro tier’s expanded context (100,000 lines) and autonomous test generation are the most direct upgrades. Plan to re-architect those workflows to take advantage of the larger context window rather than working around the per-file limit you’ve been designing for.
- If you have a multi-vendor coding-tools strategy (Copilot for some teams, Claude Code or Cursor for others, etc.), Polaris doesn’t fundamentally change the vendor-selection question, but the Microsoft-specific advantages of Copilot (Maia hardware, Azure integration, GitHub native, 100K-line context) are now stronger than they were under GPT-4. Re-run your evaluation for whichever teams are at decision points.
- Watch the post-migration third-party benchmark coverage. Vendor-published benchmark claims (like “outperforms GPT-4 Turbo on HumanEval and MBPP”) get tested against by independent reviewers within weeks of GA. The numbers that hold up to that scrutiny are the ones to trust for evaluation decisions.
The deeper takeaway is that the GitHub Copilot you’ve been using is becoming a structurally different product in August. The interface stays the same; the model underneath is fully owned by Microsoft. For most teams that’s fine, and the upgrade is probably net-positive. For teams with specific GPT-4 dependencies, the three-month fallback gives breathing room. Either way, treat August as a real platform transition, not a minor version bump.
Frequently Asked Questions
What is Project Polaris?
Project Polaris is Microsoft’s in-house AI coding model, announced at Microsoft Build 2026 on June 2, 2026. It’s a mixture-of-experts architecture with specialized sub-modules tuned for different programming languages and frameworks. Starting August 2026, Polaris replaces GPT-4 Turbo as the default model for GitHub Copilot, with an optional three-month fallback to GPT-4 for teams that want a longer transition window.
When does Project Polaris replace GPT-4 in GitHub Copilot?
Starting August 2026, with rolling automatic migration through the month for all Copilot subscribers (Individual, Business, Enterprise). Teams can opt in to a three-month fallback to keep using GPT-4 Turbo through the transition. After the fallback window, Polaris becomes the default and GPT-4 Turbo is no longer available as a Copilot default model.
How does Polaris perform vs GPT-4 Turbo?
Per Microsoft’s Build 2026 announcement, Polaris outperforms GPT-4 Turbo on the standard HumanEval and MBPP coding benchmarks, with particular gains in lower-resource programming languages like Rust and Haskell where the MoE architecture’s domain specialization helps most. The benchmark numbers are vendor-published positioning; independent third-party benchmarks haven’t been published yet and are worth waiting for if benchmark precision matters to your evaluation.
What’s new in the Pro tier with Polaris?
Two material capabilities. First, multi-file context up to 100,000 lines, which lets the model reason across substantial chunks of a real codebase in a single inference (rather than having context fed piecemeal through retrieval). Second, autonomous test generation, where Polaris generates and runs test cases for code under development without a developer in the loop. Both capabilities shift the work pattern from “AI suggests, developer reviews” toward “AI executes, developer verifies the result.”
What is Maia and why does it matter for Polaris?
Maia is Microsoft’s in-house AI silicon, designed for training and serving large AI models inside Azure. Polaris runs on Maia accelerators, which Microsoft says reduces per-inference latency and lowers cost relative to running an equivalent workload on third-party hardware (typically NVIDIA’s H100/H200 line). The strategic point is vertical integration: Microsoft owns the model (Polaris), the silicon (Maia), the cloud (Azure), the editor (VS Code), the IDE plugin (Copilot), and the developer platform (GitHub). No other 2026 coding-AI product has that depth of integration.
Why did Microsoft build its own model instead of staying on GPT-4?
The seven-year exclusive partnership between Microsoft and OpenAI ended in April 2026 after months of negotiation. Microsoft retained an equity stake and a continued commercial relationship with OpenAI, but the exclusivity, data-sharing terms, and model co-development terms all changed. Polaris is the first public artifact of what Microsoft has been building during the latter years of the partnership: a credible path to AI independence that lets the company compete on model quality, not just on distribution. The strategic case is margin capture, capability differentiation, and supply security; the operational case is what the next several years will determine.
How does Polaris compare to Claude Code, Cursor, Codex, and other coding tools?
The competitive landscape now has GitHub Copilot powered by Microsoft’s own model (Polaris) rather than by GPT-4, which raises the differentiation at the model layer. Claude Code (Anthropic’s stack, with Dynamic Workflows for parallel-agent code execution) is the most direct equivalent in the agent-native coding category. Cursor (multi-model, Claude or GPT-4 or Gemini selectable) is the most direct IDE-style competitor. OpenAI Codex (now available across mobile, CLI, and IDE surfaces) is the OpenAI-stack equivalent. Each product is converging on the same end-state: AI that writes code, generates tests, runs the tests, and reports results, with the model layer increasingly differentiated by vendor.
What does Polaris mean for the broader Microsoft AI strategy?
Polaris is the coding-specific reasoning engine; it’s the most visible piece of a broader Microsoft AI-independence push. The companion announcements at Build 2026 included the MAI v2 model suite (MAI-Image-2.5 for image generation and editing, MAI-Voice-2 for multilingual TTS, MAI-Transcribe-1.5 for transcription). Together, Polaris and MAI v2 form a complete multimodal AI stack designed to provide Microsoft customers with alternatives to OpenAI’s models across text, code, image, voice, and transcription. Microsoft is signaling that it’s building toward not depending on OpenAI, rather than toward extending the OpenAI relationship.
