19–22 May 2025, Seattle (hybrid, four days). Build 2025 was the first edition Microsoft stretched to four full days, and the framing was clean enough to print on a t-shirt: 2024 was the year of the assistant; 2025 is the year of the agent. We've sent someone to Build every year since 2012, and this was the edition where the word "agent" stopped being a demo on a stage and started being a platform — with the unglamorous plumbing underneath it that "platform" actually requires.
A year earlier, every hallway conversation was about what a Copilot could suggest. In 2025 the conversation moved to what an agent could do on your behalf — open a pull request, run the tests, call an API, act across your data — and, just as importantly, how you keep all of that under control. Microsoft framed the whole event around "the age of AI agents and building the open agentic web," and shipped north of fifty announcements to back the slogan up. Below is what we actually took away, why it mattered for a Microsoft-stack shop like ours, and the one announcement we think will outlast all the others.
"The year of the agent" was not just a slogan
Satya Nadella opened by placing 2025 firmly on a timeline that runs from the early web through to autonomous software:
"The current shift is building out the open agentic web at scale in 2025. The industry is moving from few apps with vertically integrated stacks to an open, scalable, agentic web platform." — Satya Nadella, Build 2025 keynote.
The phrase that stuck — and that Microsoft built the entire conference around — was the open agentic web: a world where agents don't just live inside one vendor's app but discover each other, call each other, and act across the web on a shared set of open protocols. That word open is doing a lot of work, and it's the reason a company our size pays attention. An agentic web that belongs to one cloud is a moat. An agentic web built on protocols anyone can implement is infrastructure — and infrastructure is something we can build a business on top of without betting the farm on a single roadmap.
The skeptic's reading is fair: "the year of the agent" is exactly the kind of line a keynote produces on schedule. We've sat through enough of them to recognise the genre. But what made 2025 different from the previous year's assistant hype was that the protocols and the production tooling actually shipped alongside the slogan, not six months behind it. You could leave the keynote and start wiring agents together the same week — and we did. That's the test we apply to every Build: not how good the demo looked, but whether there was a real dotnet add package or a real endpoint waiting for us when the lights came up. In 2025 there was.
There's also a quieter shift worth naming. In 2024 the questions developers brought to Build were can it write code at all, and is it any good? By 2025 those questions had been settled in the affirmative, and the new questions were harder and more grown-up: how do I let an agent act on my systems without handing it the keys; how do I audit what it did; how do I keep a human on the decisions that matter? The whole conference, read charitably, was Microsoft's answer to that second set of questions. That's a more interesting conference than a parade of capabilities, and it's the one we'd been waiting for.
The GitHub Copilot Coding Agent grew up
The headline for developers was the GitHub Copilot Coding Agent — an asynchronous, autonomous coding agent embedded directly in the GitHub platform and reachable from VS Code, available the day of the keynote. Microsoft's own framing was that Copilot was "evolving from an in-editor assistant to an agentic AI partner with a first-of-its-kind asynchronous coding agent integrated into the GitHub platform." GitHub also open-sourced Copilot Chat in VS Code the same week, which is its own small statement of intent about where the value is supposed to live.
In practice it means you hand the agent a GitHub issue, and it goes off and works: it clones the repo into a secure environment, analyses the whole codebase, makes cross-file edits, generates and runs tests, fixes bugs, suggests terminal commands, and comes back with a draft pull request — complete with a session log so you can see exactly what it did and why. The "asynchronous" part is the genuinely new bit, and it's easy to undersell. The 2024 Copilot sat in your editor and waited for you; it was a faster way to type. The 2025 coding agent runs while you do something else and pings you when there's a PR to review. That's a different relationship with the tool entirely — less "autocomplete on steroids," more "a junior teammate you delegate a ticket to and check in on later."
We want to be honest about how we read this, because the gap between a good demo and something we'll put in a customer's repo is where our job actually happens. The pattern is real and useful, and we've adopted versions of it in our own work since. But the load-bearing word is draft. An agent that opens a PR you still review, approve, and merge is a force multiplier; an agent that merges itself is a liability in the kinds of systems we build, where a bug isn't a CSS regression but a missed export, a failed payment, or a compliance finding that surfaces three months later in an audit. The 2025 design got that balance right: the human stays on the merge button, the session log makes the agent's reasoning inspectable, and the work lands in the same review process every other change goes through. That single set of decisions is why we trusted it enough to put it into our workflow at all — not because the demo was impressive, but because the guardrails were the headline as much as the capability.
It also slots neatly into how we already think about delegation inside the company. The good version of an agent isn't the one that does the most; it's the one that's honest about what it did and leaves the irreversible step to a person. Build 2025 was the first year the platform genuinely agreed with us on that.
Copilot Agent Mode everywhere — and multi-model on purpose
Alongside the coding agent, Microsoft pushed Copilot Agent Mode out across the editors developers actually use — Visual Studio, VS Code, JetBrains, Eclipse, and Xcode — rather than confining the good stuff to a single first-party IDE. For a company that has every commercial incentive to make its own editor the only place the magic happens, shipping Agent Mode into JetBrains and Xcode is a notable act of restraint.
The detail we cared about most was multi-model support as a first-class option: Anthropic, Google, and OpenAI models selectable inside the same agent experience. For a vendor that owns one of the largest model partnerships in the industry to ship a front door where you can pick a competitor's model is a meaningful signal. It tells you Microsoft had decided the durable value is the agent platform and the tooling around it, not lock-in to any one model — and that posture is exactly what protects our customers from betting their platform on a single lab's roadmap. Models will keep leapfrogging each other on the benchmarks; the team that designed for swapping them out will age a lot better than the team that hard-wired one in.
This is the kind of decision that doesn't make a flashy demo but quietly de-risks years of customer work. When a client asks us "what happens if the model we're standardising on falls behind, or changes its pricing, or its terms?" the honest answer in 2025 became "you change a dropdown." That's worth more to a Mittelstand customer planning a five-year platform than any single model being a few points higher on a leaderboard.
Azure AI Foundry: models as a utility, including Grok 3
Azure AI Foundry continued its march toward being Microsoft's unified AI app-and-agent factory, and 2025 was the year the catalogue crossed into "model-as-a-utility" territory. Microsoft put the catalogue at "more than 1,900 partner-hosted and Microsoft-hosted AI models," sitting on top of more than 10,000 open-source models from Hugging Face, with Meta's models in the mix as well. At that scale you stop thinking about "which model" the way you think about "which database engine" and start thinking about it the way you think about electricity — a utility you tap, govern, and bill, not a relationship you negotiate from scratch each time.
The eye-catching addition was Grok 3 and Grok 3 Mini from xAI, and the important word in Microsoft's own description was billed:
"With Azure AI Foundry Models, we're bringing Grok 3 and Grok 3 mini models from xAI to our ecosystem, hosted and billed directly by Microsoft."
Hosted and billed by Microsoft means an enterprise can use a frontier model from a third party under Azure's contracts, governance, and a single invoice — no separate vendor relationship, no separate trust assessment, no second procurement battle. That sounds smaller than "a new model," but it's the feature that actually moves what a German Mittelstand customer is allowed to deploy. The blocker on adoption in our world is rarely the model's quality; it's the legal, data-residency, and procurement review that a new external vendor triggers. Folding the model under the Azure relationship the customer already has makes the hard part disappear.
The other Foundry news that lands directly in our work was the general availability of the Azure AI Foundry Agent Service, which folded Semantic Kernel and AutoGen into a single developer-focused SDK and added Agent-to-Agent (A2A) and Model Context Protocol support for orchestrating multiple specialised agents on a complex task. The "two frameworks become one supported SDK" consolidation matters more than it sounds. We'd watched teams agonise over Semantic Kernel versus AutoGen the way people used to agonise over framework choices that turned out to be one-way doors. Collapsing them into a single supported SDK is the difference between an experiment we'd hesitate to recommend and something we'll put our name on in production.
NLWeb: "HTML for the agentic web"
The most quietly ambitious announcement was NLWeb, an open-source project for adding a natural-language AI interface to any website with very little code. Microsoft's pitch was deliberately grand: it introduced NLWeb as something it believes "can play a similar role to HTML for the agentic web."
The analogy is the whole point, and it's worth unpacking rather than waving past. HTML solved publishing — how to put content on the web in a form anything could render. NLWeb tries to solve the next problem: how humans and agents query that content once it's there. It reads formats already in the wild — Schema.org, RSS — and layers a natural-language interface over them using a model of the developer's choosing, so you're not re-describing your catalogue in some new proprietary shape; you're exposing what you've already published. And the detail that made it click for us: every NLWeb endpoint also runs as a Model Context Protocol server. Expose your content through NLWeb and you've simultaneously made it callable by any MCP-aware agent — the conversational widget for humans and the machine interface for agents are the same endpoint.
We'll keep our skepticism on the table, because the comparison is doing a lot of marketing work. Whether NLWeb actually becomes the HTML of this era is unknowable today; most projects that christen themselves "the HTML of X" are forgotten within two years. But building it directly on MCP rather than on a bespoke protocol is the move that gives it a real chance, because it means NLWeb doesn't have to win on its own — it rides whatever momentum MCP has. Betting on the plumbing instead of the brand is usually the smart bet, and it's the part of NLWeb we'd actually wire up for a customer today.
The Model Context Protocol became the standard underneath everything
If we had to keep one thing from Build 2025, it's this. The Model Context Protocol (MCP) went from an interesting, Anthropic-originated spec to the connective tissue Microsoft committed to across its whole stack. Microsoft announced broad first-party MCP support spanning GitHub, Copilot Studio, Dynamics 365, Azure AI Foundry, Semantic Kernel, and Windows 11 — and Windows became a first-class MCP host, with built-in MCP servers exposing core system functions like file-system access, window management, and integration with the Windows Subsystem for Linux, so agents can call native OS capabilities through the same protocol they use for everything else.
Then came the governance signal, which is the part that turned a promising standard into a safe bet: Microsoft and GitHub joined the MCP Steering Committee to help advance secure, at-scale adoption of the protocol, contributing an updated authorization specification and the design of an MCP server registry service. That last detail matters more than it reads. A protocol one company controls is a product; a protocol stewarded by a committee with multiple large players behind it — and with a serious answer to authorization, which is exactly where a naive agent protocol gets dangerous — is infrastructure you can plan around for years. The authorization work in particular is what lets us take MCP into a regulated customer environment with a straight face.
Rounding out the on-device story, Windows AI Foundry arrived as a unified platform for the AI developer lifecycle — covering training and inference on Windows — so the same agentic ambitions extend to apps that run locally rather than only in the cloud. For customers who can't or won't send everything to a cloud endpoint, that local path isn't a nice-to-have; it's the difference between a project being possible and not.
Why it mattered for us
Strip away the keynote theatre and Build 2025 was almost tailor-made for a shop like ThreeBIT:
- MCP becoming a real, governed standard is the single most useful thing for our customer work. Until 2025, every agent integration was a one-off, and one-offs are exactly the kind of thing that quietly rots inside a maintenance contract. Now we can wire Microsoft 365 Copilot, GitHub Copilot, and our own customer-built agents through the same protocol, with the same auth model. That collapses a whole category of bespoke glue code — the most expensive code there is, because nobody remembers how it works two years later.
- The coding agent is a force multiplier precisely because the human keeps the merge button. We adopted the "agent opens a draft PR, a person reviews and merges" pattern because it adds speed without removing control. In our industries that ordering is non-negotiable, and Build 2025 was the year the platform shipped it as the default rather than something we had to bolt on ourselves.
- Model optionality protects our customers. Multi-model Agent Mode, a Foundry catalogue measured in the thousands, and third-party frontier models like Grok 3 billed through Azure mean we never have to bet a client's platform on one vendor's roadmap. That's the same reason we've always liked the open, foundation-governed parts of the .NET world.
- NLWeb and Windows AI Foundry round out the picture at both ends — the public, agent-readable web at one end and fully local, on-device agents at the other — both speaking the same protocol as everything in between.
None of it changed our north star: ship things that have to work the first time, for industries where a failure isn't cosmetic. Build 2025 just gave us a standard protocol, a trustworthy agent pattern, and a model marketplace to do it with. We left Seattle betting on the open-agentic-web thesis. A year on, with everything that came after it, we still are.
Sources & further reading
- Microsoft — Microsoft Build 2025: The age of AI agents and building the open agentic web (official blog): https://blogs.microsoft.com/blog/2025/05/19/microsoft-build-2025-the-age-of-ai-agents-and-building-the-open-agentic-web/
- GitHub — GitHub introduces coding agent for GitHub Copilot (newsroom): https://github.com/newsroom/press-releases/coding-agent-for-github-copilot
- Microsoft for Developers — A Developer's Guide to Build 2025: https://developer.microsoft.com/blog/a-developers-guide-to-build-2025
- Microsoft Foundry Blog — Announcing Grok 3 and Grok 3 Mini on Azure AI Foundry: https://devblogs.microsoft.com/foundry/announcing-grok-3-and-grok-3-mini-on-azure-ai-foundry/
- Azure Blog — Azure AI Foundry: Your AI App and agent factory: https://azure.microsoft.com/en-us/blog/azure-ai-foundry-your-ai-app-and-agent-factory/
- Windows Experience Blog — Securing the Model Context Protocol: Building a safer agentic future on Windows: https://blogs.windows.com/windowsexperience/2025/05/19/securing-the-model-context-protocol-building-a-safer-agentic-future-on-windows/
- InfoWorld — NLWeb: Tapping MCP for natural language web search: https://www.infoworld.com/article/4019814/nlweb-tapping-mcp-for-natural-language-web-search.html
- TechCrunch — xAI's Grok 3 comes to Microsoft Azure: https://techcrunch.com/2025/05/19/xais-grok-3-comes-to-microsoft-azure/
The "year of the assistant / year of the agent" line is a widely used framing of the keynote rather than a single verbatim Nadella quote; the directly quoted sentences above are reproduced as Microsoft and Satya Nadella stated them.
Image credits
All photos are used under their respective Creative Commons licences; we are grateful to the photographers.
- Seattle Skyline — © Maëlick, CC BY-SA 2.0, via Flickr (source).
- PROJECT BOOT Dev Mode codes Preview — © Deliveramable, CC BY-SA 4.0, via Wikimedia Commons (source).
- 20101210-NodeXL-Twitter-pdfleaks — © Marc_Smith, CC BY 2.0, via Flickr (source).