Microsoft Build 2026: two days in San Francisco, and the first one we watched from home

4. June 2026

  • Home
  • Blog
  • Microsoft Build 2026: two days in San Francisco, and the first one we watched from home
Microsoft Build 2026: two days in San Francisco, and the first one we watched from home

2–3 June 2026, Fort Mason Center, San Francisco (two days). Build 2026 wrapped up yesterday afternoon on a pier overlooking San Francisco Bay. We followed all of it on the livestream from the office in Ibbenbüren — and that sentence is harder to write than it sounds, because it's the first Microsoft Build we haven't been at in person since 2012.

More on that further down. First, what actually happened — because a lot did, and Microsoft packed it into half the runtime of last year.

San Francisco waterfront skyline at dusk

A smaller, sharper Build

Last year's Build was four days in Seattle. This year it was two days at Fort Mason, capped at a few thousand in-person attendees who had to apply for a seat rather than just buy one, with everything else pushed to the free livestream. Microsoft put the new philosophy right on the tin: "Real code. Real systems. Real workflows. No fluff."

That repositioning is the real headline, and it's worth sitting with for a second. Build has spent the better part of a decade growing into a sprawling, keynote-heavy spectacle. In 2026 Microsoft deliberately ran the other way: fewer people, fewer days, more lab time, more access to the engineers who actually shipped the things on stage. The reasoning the company kept circling back to is that the question developers bring to Build has changed. In 2025 everyone wanted to know what AI could do. In 2026 they want to know how to govern it, ground it in their own data, control its cost, and put it into production without it quietly going off the rails. You don't answer that question with a stadium. You answer it in a room.

We happen to think that's the correct call. It also, as it turns out, changed our own travel maths — but hold that thought.

Fort Mason Center on the San Francisco waterfront, the Build 2026 venue

"Agents are the new applications"

If 2025 was the year of the agent, 2026 was the year Microsoft tried to make agents ordinary — a normal part of the stack, with the unglamorous plumbing that "normal" requires: identity, sandboxing, orchestration, observability, billing.

The framing came from a GitHub-and-developer keynote rather than a single Nadella mic-drop. Kyle Daigle, GitHub's COO, put the developer at the centre of it:

"Platforms shift when developers build. We explore, choose tools, dream, create."

And he named the tension every team we work with already feels:

"There's a duality in being a developer — you're a tinkerer, choosing your own tools and models, and you're an enterprise builder, shipping systems that demand governance, security and trust from day one."

That duality is basically the whole conference in one sentence. Here's the plumbing they shipped to address it:

  • Microsoft Agent Framework 1.0 went GA — a production SDK for multi-agent orchestration with first-class Python and .NET support, covering skills, memory, context and middleware. This is the bit that matters most to us: the experimental "look what an agent can do" phase is over, and there's now a supported framework with our runtime in it.
  • Microsoft Execution Containers (MXC) — OS-enforced sandboxes so an agent can act without you handing it the keys to the whole machine.
  • An Agent Orchestrator service (preview later this summer) for load-balancing across large fleets of agents, wired into Azure Logic Apps.
  • Microsoft Scout, a personal "always-on" work agent that lives across Teams, Outlook, OneDrive and SharePoint, learns how you work, and chases down the small stuff (scheduling conflicts, hand-offs) on your behalf. It's in private preview to start.
  • A GitHub Copilot App — an agent-native desktop experience with a single "My Work" view across sessions, issues and PRs, isolated worktrees so parallel agents don't trip over each other, and an Agent Merge flow that watches CI and merges a PR once the conditions are green.

The worktree detail made us grin, because it's exactly how we've been running our own AI-assisted work for a while: give each agent its own isolated copy of the repo, let them work in parallel, merge when the checks pass. Seeing it become a first-class product feature is a good sign the pattern is real and not just our habit.

VS Code also picked up multi-agent support — a planner that decomposes a goal and hands sub-tasks to specialist agents — with humans still approving every merge. That "human approves the merge" line showed up again and again, and rightly so. Developers tolerate automation that saves time and bristle at automation that hides control. An assistant that suggests a function is welcome; an agent that rewrites your repo, opens a PR and declares victory needs to earn a lot more trust first.

Microsoft brought its own models

The most strategically loaded thread of the week wasn't a single product — it was Microsoft steadily reducing how much it depends on any one model provider.

The company introduced its MAI model family, led by MAI-Thinking-1, billed as its first in-house text reasoning model (around 35B active parameters in a sparse mixture-of-experts, with a large context window) and — Microsoft says — trained without distilling from another lab's models. Alongside it came image, voice and transcription models, plus small on-device models aimed at fully local, offline agents. There's also Project Polaris, reported to become GitHub Copilot's default coding model, running on Microsoft's own Maia accelerators in Azure.

We'd flag the usual caution here: the headline benchmark claims for these models are, for now, Microsoft's own, made about models still in closed preview. We'll believe the leaderboard when independent evaluators get their hands on them. But the direction is unmistakable and it's the right one for anyone building on Azure: optionality. A model-agnostic control plane in Azure AI Foundry that routes between MAI, OpenAI, open-source and your own fine-tunes based on latency, cost and accuracy is worth far more to our customers than any single model being a few points higher on a chart.

Windows became an agent OS

This was the part that would have been most fun to see in the room. Microsoft repositioned Windows itself as a platform for AI agents:

  • A Windows Agent Framework (released under the MIT licence) for running agents across local machines, Cloud PCs and Azure Arc edge devices.
  • Windows AI APIs extended beyond NPUs to CPUs and GPUs, with a DirectML 2.0 runtime doing hybrid inference and a catalogue of optimised small models that run fully offline.
  • A Copilot Agent SDK so a custom agent can show up in Copilot, Teams, Outlook and right on the taskbar.

And — buried in the developer news but guaranteed to get the biggest cheer of any announcement all week — you can move the Windows taskbar again. Eleven years of agentic ambition and the crowd still erupts for "the taskbar can go back on the left." Never change, developers. There was, notably, no Windows 12.

A packed conference hall watching a keynote presentation — the kind of room we'd normally be sitting in

Azure, data, and the things we'll actually deploy

Underneath the agent story, the Azure and data announcements are the ones that will land in our customer projects first:

  • Azure AI Foundry continued maturing into the hub for building, testing, monitoring and governing agents at scale, with that model-agnostic control plane front and centre.
  • Azure HorizonDB — a new fully managed, PostgreSQL-compatible database built for cloud scale, with vector search and direct lines into Foundry and Fabric. A first-class Postgres-compatible managed option with vectors built in is genuinely useful.
  • Azure Cobalt 200 VMs, pitched at roughly a 50% performance bump for agentic workloads.
  • Microsoft Fabric got Fabric IQ (a shared context layer for agents and real-time analytics) and a GPU-accelerated data warehouse in early preview — Microsoft's research behind it picked up a best-paper award at SIGMOD 2026, which is not nothing.

On the tooling side, Visual Studio is getting AI agents that don't just chat but actually debug, profile and test, plus pre-build error checking and AI-assisted merge-conflict resolution, and modernisation helpers that migrate Web Forms to Blazor and bolt Aspire onto existing apps. For a shop like ours that lives in Visual Studio and .NET all day, the migration tooling alone is worth the price of admission — and the price of admission was a livestream login.

The moonshots: quantum and a non-Windows agent device

Two announcements were pure "ten years out" material.

Majorana 2, the next iteration of Microsoft's topological quantum chip, claimed a thousand-fold improvement in qubit reliability and coherence measured in seconds, with the timeline to a scalable quantum machine pulled forward to around 2029. The claims are bold enough that the market reacted with healthy skepticism, and so do we — but the use of Microsoft's own agentic "Discovery" platform to design the chip is a genuinely interesting glimpse of AI doing science rather than slideware.

And Project Solara — an agent-first computing platform that, surprisingly, isn't Windows-based at all. It runs a lightweight OS built on Android (AOSP), generates its interface on the fly per screen, and loads cloud agents on demand, with concept "badge" and "desk" devices aimed at frontline and ambient work. It's a concept with pilots rather than a product you can buy, but it tells you where Microsoft thinks the puck is going: a world where the agent, not the app or even the OS, is the thing you interact with.

Why we watched from Ibbenbüren this year

Now the part that stung a little.

We've sent someone to Build every year since 2012. It's been part of the rhythm of the company — the early flight, the jetlag, the hallway conversations that turn into a roadmap item three weeks later, the small ritual of standing in a very long coffee queue with people who care about the same obscure things we do.

This year we watched it on a screen. Not because we stopped caring, but because the maths quietly stopped working. A two-day event — application-gated, in San Francisco — means two days of content against transatlantic flights from northern Germany, several nights of San-Francisco-priced hotel, the ticket, and two people out of the office for the better part of a week. When Build was four days, that investment bought enough depth, enough sessions, and enough face time to clearly pay for itself. At two days, the honest answer is that the in-person premium no longer cleared the bar versus an excellent free livestream and the recordings.

We want to be fair about this: a tighter, more technical Build is, on the whole, a better conference. We're glad Microsoft made the cut. It's just that the same change that makes the event sharper for the people in the room also makes the journey there harder to justify from 8,500 kilometres away. Both things are true at once.

Empty auditorium seats after a conference session

So we'll say it plainly, with no bitterness: we missed it. We missed being in the room when the taskbar news landed and a thousand engineers cheered for a feature from 2009. We'll be watching the format next year, and if there's a strong reason to be there in person — a partner summit attached, a longer programme, the right sessions — we'll be on the plane again. The streak paused; it didn't end.

Following the Build 2026 livestream from a desk with a coffee

What it means for our customers

Strip away the spectacle and Build 2026 was reassuringly on-message for a Microsoft-stack shop like ThreeBIT:

  • The agent plumbing is production-grade now. Agent Framework 1.0 with .NET support, OS-level sandboxing, and orchestration mean we can build agents into customer systems with governance and identity from day one — exactly the "enterprise builder" half of Daigle's duality.
  • Model optionality protects our customers. A control plane that routes across models means we're not betting a client's platform on one vendor's roadmap — the same reason we've always liked the open, foundation-governed parts of the .NET world.
  • Postgres-compatible managed data with vectors (HorizonDB) and agent-aware tooling in Visual Studio slot straight into how we already build.

None of it changes our north star: ship things that have to work the first time, for industries where a bug isn't a CSS regression but a missed export, a failed payment, or a compliance finding. The tools just got better at helping us do that.

See you in San Francisco — or on the livestream — in 2027.

Sources & further reading

Single-source items — the MAI/Project Polaris benchmark claims, Project Solara details, and exact attendance/ticket figures — are reported here with appropriate caution; treat the model leaderboard claims as Microsoft's own until independently verified.

Image credits

All photos are used under their respective Creative Commons licences; we are grateful to the photographers.

Microsoft Build AI Agents Azure AI Foundry GitHub Copilot .NET MCP
BACK TO BLOG