Microsoft Build 2026: Project Polaris, Windows Agent Framework and the end of OpenAI dependence

Microsoft Build 2026: Project Polaris, Windows Agent Framework, and the end of OpenAI dependency

🔎 Why Microsoft just changed all the rules of the game

From June 2 to 3, 2026, in San Francisco, Microsoft didn't just host a standard developer conference. It executed a strategic pivot of rare brutality.

The publisher unveiled five major announcements that all tell the same story: the end of dependency on OpenAI. Project Polaris replaces GPT-4 Turbo in GitHub Copilot. Windows Agent Framework goes open-source under MIT. Foundry Local runs inference on-device without a single byte sent to the cloud. Azure Agent Mesh orchestrates swarms of agents. And Project Solara imagines a post-smartphone world.

Five coordinated moves, a single objective. To regain control of the AI stack, from the chip to the interface.

The essentials

• Project Polaris: Microsoft's proprietary coding MoE model, replaces GPT-4 Turbo in GitHub Copilot starting August 2026. The first concrete break with OpenAI on the product that generates the most AI revenue for Microsoft.
• Windows Agent Framework 1.0: open-source framework (MIT license) for creating agents that natively control Windows. Microsoft is betting on the ecosystem rather than lock-in.
• Foundry Local: a runtime of around 20 MB enabling on-device inference without a cloud connection. The antidote to Azure latencies and costs.
• Azure Agent Mesh: a multi-agent orchestration layer for deploying and supervising fleets of collaborative agents in production.
• Project Solara: an agent-first platform with a 5G/Android badge, a hardware vision of a smartphone-free future where the agent is the interface.

Tools and models mentioned

Project Polaris: the model breaking OpenAI's monopoly in Copilot

Project Polaris is a MoE (Mixture of Experts) coding model developed internally by Microsoft. And it is not serving as a research demo: it directly replaces GPT-4 Turbo in GitHub Copilot starting in August 2026.

This is a massive strategic signal. GitHub Copilot represents Microsoft's largest AI revenue stream. Entrusting this line to a proprietary model means stripping OpenAI of its flagship product at its most important client.

Why a MoE model for code

The MoE architecture only activates the relevant expert sub-networks for each request. The result: generation quality comparable to large generalist models, but with a divided inference cost. For code, where requests are repetitive and specialized, this is a multiplicative gain.

According to the recap from ChatForest, Polaris was specifically trained on GitHub code corpora, giving it a contextual advantage that GPT-4 Turbo did not have by design.

The implications for the coding agent market

Microsoft's move comes as the war of coding agents intensifies. xAI just launched Grok Build, its first coding CLI agent. Anthropic is pushing Claude Opus 4.7 as the absolute benchmark for coding. Google is positioning Gemini 3 Pro Deep Think in this niche.

In this context, Polaris is not just a model. It is proof that Microsoft can do without OpenAI in the most profitable segment. For developers who want to go further and create a custom AI agent, this also means that foundational building blocks are becoming accessible outside of the OpenAI ecosystem.

Cost and performance: Microsoft's calculation

The switch from GPT-4 Turbo to Polaris is not justified solely by strategic independence. It is also an economic calculation. Every Copilot request that moves from the OpenAI API to internal inference represents millions of dollars in savings at the scale of Copilot's 15 million subscriber base.

Windows Agent Framework 1.0: Microsoft opens up the game, to better control it

Windows Agent Framework (WAF) 1.0 is an open-source framework under the MIT license that allows building agents capable of natively controlling the Windows interface. Clicking, navigating, automating multi-application tasks—all of this becomes scriptable via the framework.

The choice of the MIT license is not insignificant. It is the most permissive possible. Microsoft is not looking to lock down the framework: it wants it to become the de facto standard, just as VS Code has become for code editors.

What WAF concretely enables

An agent built with WAF can read the Windows interface, interact with UI elements, and chain complex actions across multiple applications. It is the open-source counterpart to what OpenAI is experimenting with Codex Computer Use, which just arrived on Windows to remotely control your PC.

The fundamental difference: WAF is native, open-source, and does not depend on any third-party model. You can plug in Polaris, GPT-5.5, Claude Opus 4.7, or any local model.

Why open-source is the right strategy here

The desktop agent market is still in its infancy. If Microsoft had closed off WAF, developers would have created alternatives. By opening it under MIT, Microsoft ensures that the entire ecosystem built on top of Windows remains compatible. It's classic embrace-and-extend, but applied to the era of agents.

ABHS points out that WAF integrates security sandboxes to prevent agents from performing destructive actions, a critical point for enterprise adoption.

Foundry Local : 20 MB for inference without the cloud

Foundry Local is probably the most underestimated announcement of this Build. It's a runtime of about 20 MB that allows inference models to run directly on the user's machine, without any cloud connection.

20 MB. That's the size of a JPEG photo. And it's enough to run optimized models locally.

Why it's a game changer

Cloud inference has three structural problems: latency, cost, and privacy. Foundry Local tackles all three simultaneously. A locally running agent responds in milliseconds, costs zero in API calls, and never leaves the machine.

AwesomeAgents notes that Foundry Local is designed to work with the NPUs of recent processors (Qualcomm Snapdragon X, Intel Lunar Lake, AMD Ryzen AI). Inference is no longer a cloud service, it's a local hardware capability.

The connection with WAF and Polaris

The WAF + Foundry Local + Polaris combination outlines a 100% Microsoft, 100% local stack. A WAF agent that uses Polaris via Foundry Local never calls on OpenAI or Azure. It's a completely autonomous agent on the user's machine.

It's this stack that makes the OpenAI dependency obsolete. Not a brutal break, but a gradual migration made possible by technical equivalence.

Current limitations

Local models remain less performant than high-end cloud models. GPT-5.5 (score 98.2) or Claude Opus 4.7 (94.3) remain inaccessible locally. But for repetitive coding tasks and desktop automation, an optimized MoE model like Polaris is more than enough.

Azure Agent Mesh : orchestrating armies of agents

Azure Agent Mesh is Microsoft's multi-agent orchestration layer. It enables the deployment, supervision, and coordination of fleets of agents collaborating on complex tasks.

The idea is not new. But executing at Azure's scale is different from a GitHub prototype.

How it actually works

Agent Mesh provides a central registry where each agent declares its capabilities. An orchestrator assigns tasks, manages dependencies between agents, and supervises execution. If an agent fails, another with the same specialty replaces it.

This is enterprise workflow, but applied to AI agents. And it is precisely what companies expect to move from proof-of-concept to production.

Competition with autonomous agentic models

The current trend is pushing towards monolithic agentic models: GPT-5.5, Gemini 3 Pro Deep Think, Claude Opus 4.7, which handle planning and execution on their own. Microsoft takes the opposite approach with Agent Mesh: instead of a super-agent, prefer a swarm of specialized agents.

Both approaches have their merits. The monolith is simpler to deploy. The swarm is more resilient and more cost-effective (you don't activate GPT-5.5 for a task that a small local model can handle).

Project Solara: after the smartphone, the agent

Project Solara is the most ambitious vision of this Build, but also the most distant. Microsoft presented an agent-first platform accompanied by a 5G/Android badge. Not a phone. A badge.

The concept: the interface is no longer a touchscreen, it's a contextual voice agent worn on the person. The 5G badge ensures permanent connectivity. Android provides app compatibility. The agent is the mediator between the user and the digital world.

Why Microsoft is betting on the post-smartphone

The smartphone is an interface designed for humans who type and look. AI agents don't need a screen. They need connectivity, sensors, and a voice engine. The badge is the minimal hardware for this interaction.

It's speculative, but the strategic signal is clear: Microsoft doesn't want to be the AI provider for Apple's or Google's smartphone. It wants to create its own form factor.

The link to monetization

Where the 5G badge becomes interesting for Microsoft is in monetization. A Solara agent that spends its days solving problems for you is an agent that generates queries, API calls, and transactions. The hardware is an access vector. The real business remains orchestration and inference.

This model strangely echoes OpenAI's strategy, which is now opening targeted advertising to all US advertisers in ChatGPT, transforming the conversational interface into an advertising surface. Microsoft, with Solara, could do the same thing from a badge rather than a screen.

AI Geopolitics: What Polaris Means for the OpenAI Partnership

These announcements need to be put into the context of the Microsoft-OpenAI partnership. Microsoft has invested more than $13 billion in OpenAI. In exchange, it obtained exclusive access to the technology and deep integration into its products.

This deal is cracking on all sides.

OpenAI is Acting Like a Competitor

OpenAI is aggressively raising funds, developing its own infrastructure, and signing agreements with Microsoft's competitors. The exclusive partnership is dead. What remains is a commercial agreement that Microsoft can now bypass thanks to its own models.

Polaris as a Negotiating Lever

Even if Polaris does not replace GPT-5.5 in consumer products (Bing Chat, Microsoft 365 Copilot), the simple fact that it exists in GitHub Copilot changes the negotiation dynamic. Microsoft can tell OpenAI: "Your price is too high? We'll switch to Polaris."

This is exactly what happened with GPT-4 Turbo in Copilot. The model was too expensive per request. Polaris does the same thing for less money, and the money stays within Microsoft.

OpenAI Models Remain Useful, But Not Indispensable

GPT-5.5 dominates the agentic leaderboard with 98.2 points. GPT-5.4 Pro follows at 91.8. These are exceptional models that Microsoft cannot replicate tomorrow. But for 80% of enterprise use cases (coding, automation, email sorting, summaries), a specialized model like Polaris via Foundry Local is sufficient.

The 80/20 ratio is the threshold at which dependency becomes optional, rather than structural.

The agent ecosystem in June 2026: where Microsoft stands

The AI agent market is exploding. Here is where the key players stand in relation to the announcements at this Build.

The agentic models that matter

The current ranking is dominated by OpenAI, but the margin is shrinking:

Microsoft's strategy is different

Microsoft is not trying to beat GPT-5.5 in the rankings. It is building the infrastructure (WAF, Foundry Local, Agent Mesh) that makes it possible to use any of these models, including its own. It is a platform strategy, not a model strategy.

❌ Common mistakes

Mistake 1: Thinking Microsoft is completely breaking ties with OpenAI

This isn't a breakup, it's a diversification. Microsoft will continue to use GPT-5.5 and OpenAI models where they excel (complex reasoning, generalist tasks). Polaris replaces GPT-4 Turbo in a specific segment: coding in Copilot. Do not overestimate the immediate scope of this move.

Mistake 2: Believing Foundry Local replaces the cloud

Foundry Local is complementary, not a substitute. For sensitive tasks or repetitive automations, local is perfect. For heavy reasoning requiring GPT-5.5 or Claude Opus 4.7, the cloud remains indispensable. The right architecture is hybrid: local by default, cloud as a fallback.

Mistake 3: Ignoring WAF because it's "just a framework"

Open-source frameworks rarely win because of their initial features. They win because of the ecosystem built on top of them. VS Code was nothing when it launched. Today, it is the dominant editor. WAF under an MIT license could follow the same trajectory in the desktop agent space.

Mistake 4: Underestimating the stakes of the MIT license

An MIT license means anyone can fork, modify, and commercialize WAF. Including Microsoft's competitors. It's a risky but calculated bet: better to have an open ecosystem where Microsoft is the main contributor than a closed ecosystem where nobody shows up.

❓ Frequently Asked Questions

Will Project Polaris replace all OpenAI models at Microsoft?

No. Polaris specifically targets coding in GitHub Copilot, replacing GPT-4 Turbo. Consumer products like Microsoft 365 Copilot will continue to use GPT-5.5 and other OpenAI models for complex reasoning.

Does Windows Agent Framework work on Windows 10?

No. WAF 1.0 requires Windows 11 with modern accessibility APIs and NPU support. This is an additional migration lever to Windows 11 for enterprises.

Can Foundry Local run GPT-5.5 locally?

Absolutely not. GPT-5.5 is a cloud-only model. Foundry Local runs optimized and quantized models designed for local hardware (NPU, consumer GPU). The quality is lower but sufficient for common automation.

Is Azure Agent Mesh free?

No, it is a pay-as-you-go Azure service. The cost depends on the number of deployed agents, the volume of inter-agent requests, and the execution duration of workflows. A detailed pricing model is available on the Azure portal.

Will Project Solara be commercialized in 2026?

Probably not. Microsoft presented Solara as a vision and a prototype. The commercialization of a new hardware form factor generally takes 18 to 36 months after a demo of this type. 2028 is a more realistic horizon.

Is WAF's MIT license truly irreversible?

Technically yes. Once published under MIT, the code remains under MIT. Microsoft could stop contributing or create a parallel proprietary version, but the open-source fork will always exist. It is a structural commitment, not a contractual one.

✅ Conclusion

Microsoft Build 2026 marks the moment when Microsoft stopped being OpenAI's distributor to become an autonomous AI player. Project Polaris in Copilot, WAF in open-source, Foundry Local for the edge, Agent Mesh for the cloud, Solara for hardware: every piece of the stack is in place.

The OpenAI dependency isn't over. It has become optional. And in tech, optional is the first step toward obsolete. For developers who want to understand this new landscape and créer un agent IA in this emerging ecosystem, the time to train is now.