Imagine tapping your work badge and telling an AI to summarize the meeting you just left — and it replies with a neat action list on a tiny, biometric‑protected screen. That’s one of the stranger vignettes Microsoft used at Build 2026 to illustrate a single idea: software built around agents, not apps.
An Android‑rooted OS for agents
Microsoft introduced Project Solara as a chip‑to‑cloud platform that leans on an open source build of Android (AOSP) but wraps it in what the company calls the Microsoft Device Ecosystem Platform. The pitch is simple and ambitious: ditch one‑size‑fits‑all UIs and have agentic models generate interfaces just in time for each context — whether that’s a desk display or a lanyard badge.
On stage Microsoft showed two concepts: a Desk Concept (a smart display that can act like a Windows PC) and a Badge Concept (a tiny Qualcomm device with touchscreen, mic, camera, fingerprint sensor and 5G). Neither is for sale — this is exploratory hardware meant to show how a device might host or surface agentic interfaces created elsewhere. Partners for early demos include retailers, health providers and weather services, suggesting Microsoft wants to seed real enterprise scenarios before any consumer pivot.
Solara’s core idea — dynamic, context‑sized UIs produced by agents — depends on far more compute and model orchestration than most gadgets manage today. It also leans on Android’s vast developer base as a starting point, even as Microsoft layers its own enterprise pieces and identity plumbing on top. (For background on how Android itself is evolving, see recent platform work like the Android 17 beta and its one‑tap UI tweaks.) Android 17 Beta 3
Windows: developer comforts and agent containment
Build brought an avalanche of Windows‑side changes aimed squarely at people who build software and the agents that will increasingly build for them. There are practical, immediate developer niceties — Coreutils for Windows (GNU‑style tools rebuilt in Rust), Windows Developer Configurations (one‑command dev setups), and WSL containers (first‑class Linux containers directly on Windows). There’s also an experimental Intelligent Terminal that pipes agent context into your shell so you can fix failures without leaving the terminal.
Security and governance got equal billing. Microsoft Execution Containers (MXC) are a policy‑driven runtime to declare and enforce what an agent can access: files, networks, UI, input devices. Agents get OS‑enforced identities tied to Entra and Intune, so actions are attributable and admins can set containment policies. Windows 365 for Agents extends that model into managed Cloud PCs where agents can run off‑host under enterprise control.
These moves respond to a clear pain point: agents that can act autonomously amplify productivity but also multiply attack surface and unpredictable behavior. MXC, identity binding and Defender/Entra/Intune integration are Microsoft’s attempt to make agentic workflows survivable in large organizations.
Models, Copilot and the new agent runtime
Microsoft is not only designing runtimes — it’s promising new models and services to run on them. On the cloud and product side the company unveiled MAI‑Code‑1‑Flash (a coding model) and MAI‑Thinking‑1 (a reasoning model). The coding model is already integrated into GitHub Copilot and Visual Studio Code; the reasoning model is currently available to early testers through Microsoft Foundry. Microsoft cast these as efficiency plays — cheaper token costs and the ability to run models on Azure rather than pay another company to do it.
On the device edge, Windows is getting a new family of on‑device small language models (SLMs): Aion 1.0 Instruct (lightweight text tasks) and Aion 1.0 Plan (a 14‑billion parameter reasoning & tool‑calling model with a 32K context window that ships in‑box on capable devices). Those are explicitly designed so “everyday” agent work can run locally without per‑token cloud charges.
Hardware announcements pushed the same idea: dev boxes tuned for local AI. Surface RTX Spark Dev Box and a DGX Station for Windows (designed to run very large models locally) are the two extremes Microsoft teased — one to accelerate iteration on big models, the other to bring heavy inference to deskside deployments.
GitHub’s agent control center
If agents are going to do more than offer suggestions, they need a place to coordinate. GitHub unveiled the Copilot app: a desktop control center for managing multiple concurrent agent sessions, each running in its own isolated worktree or sandbox (local or cloud). New features include canvases (bidirectional work surfaces where humans and agents operate on the same artifact), Agent Merge (autonomous pull‑request handling), and policyable sandboxes that let orgs choose how far agents can go.
Copilot is also expanding runtime primitives for partners and internal tools through the Copilot SDK, and adding review tiers that let teams trade off cost and rigor when agents run code reviews. The result: a more structured, auditable flow from prompt to deployed change — which companies sorely need if agentic output continues to balloon.
Strategy, tradeoffs and why this matters
Microsoft is pushing on multiple fronts for a single strategic aim: reduce dependence on third‑party frontier models, lower long‑term costs, and own the stack where agents touch enterprise data and workflows. That explains the MAI models, Foundry integrations, the on‑device Aion family, and the containment story across MXC and Windows 365 for Agents.
But it’s a gamble. Project Solara’s vision depends on agent capabilities that are still emerging: agents that can reliably invent useful UIs, and models that can reason safely and cheaply enough to run routinely. There’s also a product challenge — convincing partners and customers to back new device classes (tiny badges? always‑on displays?) when many organizations are still wrestling with security basics.
Microsoft’s response is pragmatic: give developers better local tools and guarded runtimes so organizations can pilot agent workflows without exposing the whole company. It’s an explicit bet that the future of software will be agentic — and that long before every organization can or should run trillion‑parameter models locally, a mix of local SLMs, efficient cloud models and strong containment will make agentic work usable and governable.
One last note: this isn’t just a Windows story. The company is grafting agentic thinking onto Android foundations for specialized devices, on Windows for desktop and dev workflows, and into GitHub for code‑centric automation. That cross‑device, cross‑runtime ambition is what makes Build 2026 feel less like a list of features and more like the opening move of a system‑level play.
If you want to see how platform makers are nudging on‑device AI and interfaces beyond phones, it’s worth watching how Apple and others respond — Apple’s recent updates that push more functionality locally show this is a broader industry shove toward on‑device intelligence. iOS 26.4 has already signaled some of those same priorities.
There’s room for skepticism, and for excitement. Microsoft is trying to tame the chaos agents could unleash by giving companies the building blocks — models, containment, dev ergonomics and a runtime for agents. Whether that will birth a new gadget economy of AI badges and displays, or simply make developers’ lives less tangled, remains to be seen. But the company made its intentions very clear: it wants to be the platform where the agent era starts to feel manageable.
