Solutions for
Please select
Try the Web App
ki-werkzeuge

Microsoft Project Polaris

Redaktion ·

Microsoft is building its own coding model — why it matters to you

If you use GitHub Copilot, an OpenAI model still answers behind the scenes today. That is changing. At Microsoft Build 2026 (June 2), Microsoft unveiled Project Polaris — an in-house AI model for code, built to replace GPT-4 Turbo as the default engine in Copilot. According to Microsoft, the switchover for all Copilot subscribers begins in August 2026.

This is more than a quiet model swap. It marks the point where Microsoft cuts its dependence on OpenAI in the coding-assistant business — after the two companies ended their seven-year exclusive partnership in April 2026. If you plan coding tools, agents or the Copilot platform for your team, it helps to understand what Polaris is, what it can do (per the vendor) and which questions stay open.

What Project Polaris is

Project Polaris is Microsoft’s own AI model, purpose-built for generating and understanding code. It is positioned as the future reasoning engine for GitHub Copilot — the model that powers code completion, chat and the agent features.

Polaris bundles three things that used to be separate: by Microsoft’s own account, it now controls the model, the inference infrastructure and the developer experience — from the trained network, through the chips it runs on, to the surface inside the editor. That is the real strategic core. Until now Microsoft owned only the last link of that chain.

A note on naming: there are many “Polaris” projects

The name Polaris is used many times across tech — from hardware codenames to independent open-source projects. This article refers solely to Microsoft’s coding model for GitHub Copilot unveiled at Build 2026. Whenever you read “Polaris,” check the context: if it is about GitHub Copilot, a Microsoft-owned model and Build 2026, it is this project.

The tech — what Microsoft states

Architecture: mixture-of-experts

Microsoft describes Polaris as a mixture-of-experts architecture (MoE) with specialized sub-modules tuned for different programming languages and frameworks. MoE means, in short: instead of running the whole model for every request, a router activates only the relevant “expert” sub-networks per input. That lowers compute cost per request, because not every parameter weight fires every time.

For a coding model this is plausible: Rust code, an SQL migration and a React component tree place very different demands on the model. Domain-specific experts are a known pattern for keeping quality and efficiency up at the same time.

Hardware: Maia chips instead of third-party inference

Polaris runs, according to Microsoft, on the Maia AI accelerators — Microsoft’s own AI chips inside Azure. Microsoft cites two benefits: lower per-inference latency and lower operating cost compared with the previous GPT-4 backend. Both are the direct economic lever behind the switch: when you own the model and the chip, you pay no margin to an external model vendor and can co-tune software and silicon.

Benchmarks — read with care

According to Microsoft, Polaris beats GPT-4 Turbo on the HumanEval and MBPP coding benchmarks, with the largest gains in “low-resource” languages such as Rust and Haskell — languages with comparatively little code in the training material. Important: these figures are Microsoft’s own and have not been confirmed by independent auditors. HumanEval and MBPP also measure solving well-scoped function tasks — not working inside large, grown codebases. Real-world relevance: limited.

The rollout — timeline and fallback

The transition is meant to be non-optional, but cushioned.

| Phase | What happens | |---|---| | June 2, 2026 | Unveiled at Build; multi-agent extension for VS Code available | | from August 2026 | Polaris becomes the default engine for GitHub Copilot subscribers (automatic migration) | | Fallback window | Optional stay on GPT-4 for three months — must be configured before the switch | | after fallback | Polaris becomes mandatory |

In practice: teams that have heavily optimized their prompts, eval suites or agent workflows around GPT-4 behavior should plan for the fallback window and test Polaris against their real tasks beforehand. A model swap often subtly changes behavior — formatting, verbosity, handling of ambiguous instructions.

Polaris in the bigger picture: Microsoft’s agent platform

Polaris did not arrive alone. Build 2026 was framed around turning Windows into a platform for AI agents. Polaris is the model layer within that — the following pieces form the frame around it.

Multi-agent mode in VS Code

Alongside Polaris, a multi-agent mode for VS Code became available. Instead of working tasks sequentially, Copilot can spawn parallel subagents — say one for linting, one for test generation, one for documentation and one for security review, all running at once. An orchestrator agent decomposes the task and delegates to the specialists. This is the same pattern you know from other AI agent setups: a coordinating agent over several specialized workers.

Windows Agent Framework and Runtime

The Windows Agent Framework (WAF) shipped, per Microsoft, on April 2 and was MIT-licensed at Build. Agents are defined in YAML and not tied to a specific runtime. A separate Windows Agent Runtime at OS level is meant to run agents as “first-class” operating-system citizens rather than as ordinary application processes.

Agent Store and Azure Agent Mesh

There is also a curated Windows Agent Store (Microsoft cites an 85% revenue share for developers, matching the current Microsoft Store model) and Azure Agent Mesh, a control plane that federates agent execution across on-premises Windows servers, Windows 365 Cloud PCs and Azure Arc devices. General availability of Agent Mesh is, per Microsoft, targeted for Q4 2026.

Pitfalls and open questions

Vendor benchmarks are not independent benchmarks. Top HumanEval/MBPP scores from the maker’s own PR team say little about behavior in your codebase. Wait for third-party sources and test yourself.

Lock-in shifts, it does not vanish. Instead of depending on OpenAI, you now depend on Microsoft’s model, Microsoft’s chips and Microsoft’s agent platform. That can be cheaper and more integrated — but it remains a single-vendor dependency.

“Mandatory after fallback” is a planning risk. Anyone who permanently needs GPT-4 has to look for alternatives early or switch providers. The fallback window is short.

A date, not a verdict. As of this article (June 2026), Polaris is freshly announced. Whether it actually beats GPT-4 in daily work will only show once it is broadly in use.

FAQ

Is Project Polaris a competitor to GPT-4 or Claude?
In the coding context, yes. Polaris is Microsoft's own coding model and replaces GPT-4 Turbo in GitHub Copilot. Several reports also frame it as a response to agentic coding tools such as Claude Code gaining ground with developers.
As a Copilot user, do I need to do anything?
By default no — the migration to Polaris from August 2026 is automatic, per Microsoft. If you want to stay on GPT-4, you must actively configure the three-month fallback before the switch. After that, Polaris becomes mandatory.
Does Polaris run on your own hardware?
According to Microsoft, Polaris runs on the Maia AI accelerators in Azure. It is positioned as a hosted model, not as a locally self-hostable open-weight model.
Are the benchmark numbers reliable?
They come from Microsoft's own communications (HumanEval, MBPP) and were not independently confirmed at the time of publication. Treat them as a vendor claim, not a neutral measurement.
What does Polaris have to do with the OpenAI split?
Microsoft and OpenAI ended their exclusive partnership in April 2026. Polaris is the visible technical step with which Microsoft builds its own models to reduce dependence on OpenAI in the Copilot stack.

Conclusion

Project Polaris is less a single product than a strategic lever: with it, Microsoft owns the full chain of model, inference chip and editor for the first time. For Copilot users it means a new model under the hood from August 2026 — automatic, with a short GPT-4 fallback. Technically, the mixture-of-experts architecture on Microsoft’s own Maia chips is a reasonable efficiency play; the quality promises, however, are vendor claims so far, without independent verification.

The sober takeaway: if your team relies on Copilot seriously, plan for the fallback window, test Polaris against your real tasks rather than against benchmarks, and keep in mind that the vendor dependency shifts — it does not disappear.

Themenuebersicht

KI-WerkzeugeAgenten-Frameworks