Microsoft Made Windows an Agent Platform at Build 2026. Here's the CTO Decision Before the Windows Agent Store Goes GA

Microsoft's Build 2026 keynote didn't just preview features. It changed the procurement model for enterprise agent deployment on Windows, and the decision your team makes in Q3 will determine how much flexibility you have once the Windows Agent Store (WAS) goes generally available (GA).

On June 2 at Fort Mason in San Francisco, Satya Nadella opened Build 2026 with a cluster of announcements that, taken together, redraw what it means to run agents inside your organization. According to ChatForest's Build 2026 recap, Microsoft shipped the Windows Agent Framework (WAF) as an MIT-licensed open-source project, pushed the Windows Agent Runtime (WAR) into preview, opened the Windows Agent Store with an 85/15 developer revenue split, and named Project Polaris as the replacement default model in GitHub Copilot starting August 2026.

That last part deserves a second read. Microsoft is replacing GPT-4 with its own internally built model in its own developer product, running on its own Maia accelerators. The company that built its AI strategy on top of OpenAI is now vertically integrating the model layer. For CTOs who have approved a GitHub Copilot seat count based on OpenAI model quality, this isn't a footnote. It's a renewal conversation.

What Actually Shipped at Build 2026

Key Facts:

• 85/15 dev rev share: The Windows Agent Store pays developers 85%, versus Apple App Store and Mac App Store at 70/30. Microsoft is undercutting both platforms to win ISV distribution. (Source: ChatForest Build 2026 recap)
• Project Polaris becomes default in GitHub Copilot: August 2026, with a 3-month optional GPT-4 fallback period. Runs on Microsoft's Maia accelerators. (Source: ChatForest)
• Build 2026 keynote: June 2, 2026, Fort Mason SF, Satya Nadella opening. (Source: NotebookCheck)

Here's what Microsoft actually announced, without the marketing layer:

• Windows Agent Framework (WAF): An MIT-licensed open-source agent development framework with native agent application programming interfaces (APIs) baked into the Windows OS shell. MIT licensing means it'll get standardized fast. Expect third-party agent builders to target WAF within months.
• Windows Agent Runtime (WAR): A preview runtime that hosts and executes agents directly on Windows devices. This is the local execution environment. It pairs with the existing Windows 365 for Agents, which uses a Cloud personal computer (Cloud PC) as the agent host. Two runtimes now exist for Windows agents before you even get to Azure.
• Windows Agent Store (WAS): A curated marketplace for distributing agents to enterprise users. Adobe and Zoom are named as design partners. The 85/15 revenue share is the headline: developers keep more, so more developers build for Windows first.
• Project Polaris: Microsoft's homegrown coding model. It replaces GPT-4 as the default powering GitHub Copilot in August 2026. A 3-month fallback to GPT-4 will be available. Polaris runs on Microsoft's Maia custom accelerators, which means the inference cost structure is entirely under Microsoft's control going forward.

Why Three Runtimes Is the Real Story

The announcement that gets the most coverage is the Windows Agent Store. But the structural decision underneath it is less obvious: Microsoft now gives enterprise CTOs three distinct runtime environments for Windows agents, and the store connects to all three.

Here's the breakdown:

These aren't interchangeable. An agent built for Local Windows + WAR has a fundamentally different identity model than one running inside a Windows 365 Cloud PC. Mixing them without an explicit choice creates audit gaps, which means compliance risk.

Compare this to how Apple handles distribution: the App Store (70/30) and Mac App Store (70/30) both feed a single runtime. Microsoft is running a more complex architecture, and the 85/15 WAS rev share is the carrot to get ISVs building across all three runtimes.

For CTOs building out an AI vendor evaluation framework, this runtime trichotomy needs to be an explicit evaluation axis before any specific agent is approved. If you wait until agents are already deployed to ask "which runtime are these running on," you'll find the answer scattered across three different governance surfaces.

The named framework for thinking through this: The Three-Runtime Test. For any new Windows agent deployment, ask three questions before approving it: Which runtime does this agent live in (Local WAR / Windows 365 Cloud PC / Azure Agent Mesh)? Who owns its identity and audit log? What's the rollback path if the runtime gets deprecated or the vendor exits the store?

What This Changes for the GitHub Copilot Renewal

Project Polaris isn't just a model swap. It's Microsoft re-underwriting its own AI product stack.

When your organization approved GitHub Copilot seats, you were buying OpenAI model quality inside a Microsoft product. From August 2026, the default model is Polaris, a Microsoft-built coding model running on Maia accelerators. The 3-month GPT-4 fallback buys time, but it's a fallback, not a permanent option. After that window, staying on GPT-4 inside Copilot will likely require explicit configuration or a different product tier.

The questions your team needs to answer before the August default switch:

1. Did your Copilot seat approval include a model quality benchmark? If yes, run Polaris against it now, during the fallback window.
2. Is your organization on a GitHub Enterprise license with model customization access? If so, the Polaris migration is a configuration decision, not just a renewal decision.
3. Does your security team's AI use policy reference OpenAI specifically, or does it reference "the model powering Copilot"? Either way, a policy review is due. See Building Your AI Use Policy for what that review should cover.

The deeper issue is vendor concentration. Microsoft's move to Polaris is exactly the kind of single-vendor lock-in shift that AI vendor lock-in mitigation strategies are designed to surface early. You may be fine with Polaris, but the decision to accept it should be explicit, not default.

FAQ

Do we need to migrate off GPT-4 in GitHub Copilot in August?

Not immediately. Microsoft is providing a 3-month optional fallback to GPT-4 after Polaris becomes the default. But the fallback is temporary. The right move is to test Polaris against your team's actual coding workflows now, during the preview window, and treat the fallback as a buffer for evaluation, not a permanent stay.

Is the Windows Agent Store an enterprise-controlled or open marketplace?

Microsoft is describing it as curated, with Adobe and Zoom as design partners. But "curated" doesn't mean IT-controlled. Enterprise administrators will likely need to configure WAS access policies through Microsoft Intune or Entra-based conditional access. How granular those controls are won't be clear until GA. CTOs should pressure Microsoft account teams for specifics on enterprise tenant controls before approving any WAS-sourced agents.

The Windows Agent Procurement Checklist for Q3

Run this with your architecture and security leads before the Windows Agent Store goes GA:

Step 1: Assign every current and planned Windows agent to a runtime. Map each agent (including GitHub Copilot, any Azure OpenAI integrations, and any ISV tools with Windows clients) to one of the three runtimes: Local Windows + WAR, Windows 365 Cloud PC, or Azure Agent Mesh. Don't allow unassigned agents. Use your AI approval gates and vendor review process to enforce this.

Step 2: Define identity and audit ownership per runtime. For each runtime in use, specify which team owns the identity surface (IT, security, or platform engineering) and where the audit log lands. Make this explicit in your audit trails for AI execute actions documentation before any WAS-sourced agent is approved.

Step 3: Set a Polaris evaluation gate before August. Schedule a Copilot quality review during the 3-month fallback window. Run your top 3-5 coding workflows through Polaris. Compare output quality to GPT-4 baselines. Decide explicitly whether to accept Polaris as default or request extended GPT-4 access. Don't let the August default flip happen without a recorded decision.

Step 4: Update your vendor risk register. Add the Windows Agent Store as a distribution channel risk entry. Note that agents sourced from WAS may run across multiple runtimes and that Microsoft controls the rev share, curation criteria, and runtime compatibility specs. Cross-reference against your AI vendor lock-in mitigation strategies to document acceptable exposure before approving WAS-sourced agents at scale.

What to Do This Week

The WAS isn't GA yet. That's your window. Here's what matters before it is:

• Brief your Microsoft account team on your runtime architecture questions. Get specific answers on enterprise tenant controls for WAS before the product teams are overwhelmed with GA launch traffic.
• Pull your GitHub Copilot renewal date. If you're within 6 months of renewal, start the Polaris evaluation now. The 3-month fallback period needs to fit inside that window.
• Read the WAF MIT license. Open source licensing changes the security review process. Your AppSec team needs to assess WAF before any internal team builds on it. MIT is permissive, but that cuts both ways.
• Add "three runtimes" to your next architecture review agenda. Even if your organization isn't actively deploying Windows agents today, the runtime architecture decision shapes every future vendor evaluation you'll do. Get ahead of it while you can still make the choice deliberately.
• Check whether your AI use policy covers agent distribution marketplaces. Most policies written before 2026 don't. The WAS is a new distribution surface with its own security and procurement implications.

For the broader framework on how decisions like this fit into a multi-year AI deployment strategy, the 5 stages of AI maturity model is a useful reference for placing your organization's current readiness and knowing how aggressive to be with early WAS adoption.

Learn More

• Vendor Evaluation Framework for AI Tools
• AI Vendor Lock-In: Mitigation Strategies
• Autonomous Agent: Multi Step Goals With Tool Use
• The 5 Stages of AI Maturity