I contributed to Microsoft Build 2026 as an Agents and Apps Expert. Here Is What Production Ready AI Agents Actually Look Like

Microsoft Build 2026, Fort Mason Center, San Francisco. Photos: Dave Rendon.

Most people experience a developer conference as a spectator. I experienced Microsoft Build 2026 from the other side of the table. I was at Fort Mason in San Francisco on June 2 and 3 as a Microsoft MVP for Azure and AI, and as a confirmed Expert in the Agents and Apps track, working the Expert Meetup program. That vantage point shaped everything I took away from the event, and it is the reason I can tell you with confidence what this Build was actually about.

This article is a builder’s debrief. I am going to walk you through the single most important shift at Build 2026, the architecture Microsoft shipped to support it, and the components that matter if your job is to put AI agents into production. I will back each section with what I saw on the show floor and at the Agents and Apps booth, and I will point you to the primary sources and the exact Microsoft Learn pages so you can go deeper. If you build agents for a living, this is the map.

The one sentence that explains all of Build 2026

Agents stopped being demos and became infrastructure.

Every major announcement pointed the same direction: the hard part of agents was never the prototype. It was everything after the prototype. Isolation, identity, grounding, evaluation, governance, and a path from a shipped agent back to a better one. Build 2026 was Microsoft answering that list. As one of the Foundry leads put it on the live blog, the latest releases were designed to round out the four layers production agents had been missing.

That framing is not marketing gloss. It matched what developers were asking me at the booth, and it matched the slide that sat behind me for two days.

The booth I stood behind: agent context, knowledge, and grounding

The Agents and Apps booth. “Agent context, knowledge and grounding,” demonstrated with Foundry IQ.

The booth theme was deliberate: “Ground agents in enterprise knowledge and reasoning with Foundry IQ.” If you want to understand why grounding dominated the Agents and Apps conversation, look closely at the “Minimal Effort Example” on that screen.

A single intent goes in: “Paint for bathroom” and “Cost of bathroom paint.” What comes back is not one naive vector lookup. The system plans the query, fans out multiple searches across different sources (product manuals, blog posts), logs each step with the number of results, then merges and re ranks the candidates with a relevance score attached to each document. That is agentic retrieval, and it is the heart of Foundry IQ.

This is the part developers consistently underestimate. Retrieval augmented generation in a notebook is easy. Retrieval that respects permissions, spans heterogeneous sources, reasons about which sources to hit, and returns attributable evidence with a score, behind a single endpoint with an SLA, is the difference between a pilot and a product. The booth was showing the production version of a problem most teams are still solving by hand.

Architecture deep dive: the four layers production agents were missing

Microsoft Foundry’s Build 2026 release organized the agent lifecycle into four layers. This is the mental model I used at the booth, and it is the cleanest way to reason about the whole stack. The official roundup is on the Microsoft Foundry Build news page listed in the references below.

Layer 1, Build: Microsoft Agent Framework 1.0

Microsoft Agent Framework reached version 1.0 and general availability. It is the open source SDK that succeeds Semantic Kernel and AutoGen, and it now treats the agent harness as a first class concept: skills, context, memory, and middleware are production ready rather than bolt ons. It supports Python and .NET, graph based multi agent workflows, and the Model Context Protocol and Agent to Agent protocol for interoperability.

The detail that earns it the “production” label is composition. You can drop a GitHub Copilot SDK agent or a Claude Agent SDK agent into an Agent Framework workflow as a named participant while the orchestrator stays deterministic. New toolboxes in Foundry, in preview, unify access to web and file search, MCP, OpenAPI, and the A2A protocol so your agent reaches its tools through one consistent surface.

If you do one thing after reading this, clone the framework and run the quickstart. The repository and the samples are linked in the references.

Layer 2, Ground: Foundry IQ and the Microsoft IQ family

This is what the booth was about, and it was the announcement I found most consequential. Foundry IQ knowledge bases went generally available. A knowledge base unifies Work IQ, Fabric IQ, File Search, Azure SQL, and MCP behind one retrieval endpoint backed by an SLA. You define a reusable knowledge base once, around a topic such as employee policy or product documentation, and any number of agents connect to it instead of each agent reimplementing retrieval.

Foundry IQ sits inside the larger Microsoft IQ family, which also went generally available and is now reachable across GitHub Copilot, Microsoft Foundry, and Copilot Studio. The three layers divide the problem cleanly. Work IQ carries the semantic understanding of how your organization operates, drawn from Microsoft 365 collaboration signals. Fabric IQ provides the business ontology, the shared meaning of entities such as customers, orders, and products, so agents reason about concepts rather than raw tables. Foundry IQ centralizes knowledge retrieval and grounding for agents. Microsoft also introduced Web IQ, a set of AI native grounding APIs that extend that reach to fresh, attributable information from the open web.

The architecture lesson is simple and worth internalizing: context is now infrastructure. You provision it once and reuse it, exactly like a database or an identity provider, rather than wiring it into every project.

Layer 3, Operate: tracing, evaluation, and the agent optimizer

Shipping an agent is the start of the work, not the end. Foundry’s operate layer addresses the part teams skip until it hurts. Tracing and evaluation for hosted agents run through one OpenTelemetry pipeline, with evaluations linked back to the trace that produced them, so a bad answer is traceable to the exact execution path that caused it. An agent optimizer, in preview, turns those signals into ranked candidate improvements across prompt, tools, skills, and context, with diffs, an audit trail, and one click rollback. Rubric, also in preview, converts written policies into automated tests for agent behavior.

This is the closed loop that the word “production” actually requires. You observe real behavior, you evaluate it against policy, you generate improvements, and you roll back safely when something regresses.

Layer 4, Reach: one click publishing

The last layer is distribution. One click publishing to Microsoft Teams and Microsoft 365 Copilot is arriving, with identity and tenant policy flowing through automatically. An agent is only useful where work happens, and this removes the last mile of plumbing between a working agent and the surfaces where people already are.

The models under the agents: seven new MAI models

Demo Theater A. The seven new in house Microsoft AI models, the MAI family.

Agents need models, and Microsoft used Build to put its own first party models under the stack. I caught the “Seven new Microsoft AI models” slide in Demo Theater A. The MAI family now spans reasoning, code, image, transcription, and speech.

MAI Thinking 1 is Microsoft AI’s first reasoning model, a mid sized model with 35 billion active parameters built for high efficiency at a low token cost, designed for multi step instructions, long context reasoning, and code generation, and notably built on clean data without distillation from third party frontier models. MAI Image 2.5 serves both text to image and image to image workloads, with a faster Flash variant for production scale. MAI Transcribe 1.5 combines high accuracy with entity biasing. MAI Voice 2 added more than ten additional languages, with an ultra low latency Flash variant aimed squarely at voice agents. MAI Code 1 Flash is purpose built for GitHub Copilot and VS Code to deliver performance at lower cost. The image, transcription, and voice models are generally available now on Microsoft Foundry and the MAI Playground. The benchmark figures on the slide, such as the Arena and SWE Bench Pro numbers, are Microsoft’s own stated stats from the session.

For agent builders, the takeaway is a routing strategy. You no longer reach for one model for everything. You route reasoning to a thinking model, high volume classification to a small fast model, voice to a low latency speech model, and code to a code optimized model, and Foundry gives you the single place to do it.

Beyond Foundry: the rest of the agent platform

The show floor: robotics demos, the outdoor festival stage, and Build energy at Fort Mason.

The agent story extended well past Foundry, and the floor reflected it. A few that matter for the Agents and Apps audience:

Microsoft Scout is Microsoft’s first Autopilot agent, an always on worker with its own governed Entra identity that lives in Teams, Outlook, OneDrive, and SharePoint, built on open source OpenClaw technology with Work IQ as its context engine. The identity design is the point: every agent acts under a known, attributable directory identity rather than a shared service account.

Windows 365 for Agents gives agents secured, Intune managed, Entra joined Cloud PCs to run inside the same environments where business already happens, available as part of Agent 365, now generally available. Azure HorizonDB brings PostgreSQL into the agentic era with built in vector indexing and semantic search. And the NVIDIA partnership, visible from the Build and NVIDIA branding on the tote in my badge photo down to the RTX Spark hardware, tied a unified accelerated stack across cloud and local devices.

The robot dog drew the crowds, as robot dogs do. The architecture under the announcements is what will still matter next quarter.

What developers actually asked me at the Expert Meetup

This is the part I could only write because of where I was standing. Across two days, the questions developers brought to the Agents and Apps booth clustered into three themes, and they map exactly onto the production layers above.

First, grounding. The most frequent question was a version of “how do I connect my agent to our enterprise knowledge without rebuilding retrieval for every project.” The honest answer is now a product answer: a Foundry IQ knowledge base, defined once, reused everywhere, with permissions respected and evidence scored. The booth demo was the proof.

Second, identity. The question under the question was trust. “If an agent can take actions, whose actions are they.” The Entra agent identity model, the one Scout makes concrete, is the answer developers were relieved to hear, because it makes agent behavior attributable and governable.

Third, operations. “How do I know it works, and how do I fix it when it does not.” Tracing tied to evaluations, plus the agent optimizer with rollback, is the loop teams need before they will commit a customer facing agent.

My contribution at Build was not a keynote. It was two days of translating these announcements into answers a builder could act on Monday morning, which is the entire point of the Expert Meetup, and the most useful work I did all week.

What I would do Monday

If you build agents, here is the shortest path to value from this Build.

Clone Microsoft Agent Framework and run the quickstart in Python or .NET. Build one small agent end to end. Then replace its hand rolled retrieval with a Foundry IQ knowledge base and watch how much code disappears. Wire tracing and one evaluation from day one, not after the incident. Give the agent a real Entra identity rather than a shared key. And pick a single bounded workflow to ship to Teams, so you learn the operate and reach layers on something low risk before you scale.

Closing

I came to Build 2026 as an Expert in Agents and Apps, and I am leaving with a clear conviction: the agent conversation has matured from “can we build one” to “can we run many, safely, in production.” Microsoft shipped the four layers that question requires. The booth I stood behind was a small, concrete demonstration of the largest theme of the entire event. If your work is agents, the tools to do it properly are now generally available, and the map above is where I would start.

Links and references

Microsoft Build 2026 live blog, all official announcements: https://news.microsoft.com/build-2026-live-blog/

Microsoft Foundry Build 2026 news, the four production layers: https://aka.ms/FoundryBuildNews

Microsoft Foundry Agent Service overview on Microsoft Learn: https://learn.microsoft.com/en-us/azure/foundry/agents/overview?WT.mc_id=AZ-MVP-5000671

What is Foundry IQ on Microsoft Learn: https://learn.microsoft.com/en-us/azure/foundry/agents/concepts/what-is-foundry-iq?WT.mc_id=AZ-MVP-5000671

Windows 365 for Agents pricing on Microsoft Learn: https://learn.microsoft.com/en-us/windows-365/agents/pricing-paygo-always-available?WT.mc_id=AZ-MVP-5000671

Foundry IQ general availability announcement: https://aka.ms/FoundryIQ-GA

Work IQ announcement: https://aka.ms/MBJ02yr26

Fabric IQ announcement: https://aka.ms/Azure-Data-Build26

Web IQ, next generation grounding: https://aka.ms/nextgengrounding

Seven new Microsoft AI models, the MAI family: https://aka.ms/MAI-Build

Microsoft Scout, the first Autopilot agent: https://aka.ms/ProjectLobster-Blog

Windows 365 for Agents: https://aka.ms/W365Build26Blog

Azure HorizonDB: https://aka.ms/HorizonDB-Build-blog

NVIDIA and Microsoft unified stack: https://blogs.nvidia.com/blog/microsoft-build-windows-local-cloud-devices/

Microsoft Agent Framework on GitHub: https://github.com/microsoft/agent-framework

Microsoft Agent Framework samples on GitHub: https://github.com/microsoft/Agent-Framework-Samples

Rayfin on GitHub: https://github.com/microsoft/rayfin