Overview
The “Keynote in 5” video takes a different approach to Build 2025 coverage. Rather than walking through every product announcement, it goes deeper on the technology behind the big ideas — unpacking how AI agents actually work, what Model Context Protocol really is, and how developers fit into the enterprise AI adoption story.
This blog follows that same approach: less product marketing, more technical context. If you want to understand the why and how behind Microsoft’s Build 2025 announcements, this is the post for you.
The Tech Behind the Agentic Web
What Is an AI Agent, Really?
The term “AI agent” gets used loosely, so let’s be precise. An AI agent is a system that:
- Receives a goal (not just a single prompt)
- Plans a sequence of actions to achieve that goal
- Executes those actions using available tools (web search, code execution, APIs, file access)
- Observes the results and adjusts its plan accordingly
- Iterates until the goal is achieved or it determines it cannot succeed
- MCP Servers: Expose capabilities (database queries, API calls, file access) in a standardised format
- MCP Clients: AI agents that discover and call those capabilities
- Authorization Layer: Controls what agents can access and when
- Research Agent — Queries internal databases and web sources for relevant data
- Analysis Agent — Processes the data, identifies trends and anomalies
- Writing Agent — Drafts the narrative sections of the presentation
- Visual Agent — Generates charts and suggests slide layouts
- Review Agent — Checks the final output for accuracy and consistency
- Performance metrics: Latency, throughput, and response quality for each agent
- Quality metrics: Accuracy, relevance, and safety scores
- Cost metrics: Token usage and financial tracking per agent/workflow
- Safety metrics: Content policy violations and risk flags
- Codebase understanding: Copilot indexes the repository to understand structure, conventions, and dependencies
- Task decomposition: It breaks down the assigned task into a series of file edits, test runs, and validation checks
- Tool use: It uses code search, file read/write, test runners, and linting tools via MCP
- Iterative refinement: It runs tests, observes failures, and revises its implementation
- Pull request creation: Once satisfied with the result, it opens a PR with a clear description of what was done and why
- Latency: Cloud round-trips add 100-500ms to every AI call. On-device inference can be sub-10ms
- Privacy: Sensitive data never leaves the device
- Offline capability: Agents continue working without internet connectivity
- Cost: Inference on local NPU (Neural Processing Unit) hardware is cheaper per call than cloud API usage
- 15 million GitHub Copilot users (developer community fully engaged)
- 230,000+ organisations using Copilot Studio (enterprise deployment at scale)
- 90% of Fortune 500 companies using Microsoft Copilot offerings
This is fundamentally different from a chatbot that responds to individual queries. Agents are autonomous executors with access to real-world capabilities.
Microsoft’s entire Build 2025 platform is designed to support this pattern at every level — from individual developers using GitHub Copilot to enterprises running multi-agent workflows in Azure AI Foundry.
Deep Dive: Model Context Protocol (MCP)
The Problem MCP Solves
Before MCP, connecting an AI model to external tools was custom work every time. Want your agent to query a database? Write custom integration code. Want it to search the web? Write another integration. Want it to call your internal API? Yet another integration.
This created massive friction and resulted in AI systems that were islands — powerful but isolated.
What MCP Does
Model Context Protocol defines a standard interface between AI models and the tools/data sources they need to interact with. Think of it like REST for AI tool use:
When Microsoft says it has deployed MCP support across GitHub, Copilot Studio, Azure AI Foundry, Windows 11, Dynamics 365, and Semantic Kernel, it means any MCP-compatible agent can now talk to all of those platforms without custom integration work.
Why the MCP Steering Committee Matters
By joining the MCP Steering Committee alongside other major players, Microsoft is ensuring that MCP evolves as a genuinely open standard — not a standard controlled by any single vendor. This is the right move: open standards create larger, healthier ecosystems than proprietary protocols.
Deep Dive: Azure AI Foundry Agent Service
Multi-Agent Orchestration
The Azure AI Foundry Agent Service (now generally available) is designed for multi-agent orchestration — the coordination of multiple specialised AI agents working together on a complex task.
Here’s a concrete example of how this works:
Goal: “Prepare a quarterly business review presentation”
Each agent is specialised. The orchestrator (Azure AI Foundry Agent Service) coordinates the workflow, passes outputs between agents, handles errors, and delivers the final result.
This is what “agentic AI” looks like in practice — and it’s now available as a managed Azure service.
Observability: The Missing Piece
One of the most technically important announcements was Azure AI Foundry Observability, which provides:
Without observability, running agents in production is flying blind. This feature is what separates a demo from a deployable enterprise system.
Deep Dive: GitHub Copilot as Autonomous Agent
How the Autonomous Coding Agent Works
Under the hood, GitHub Copilot’s new autonomous agent capability uses a combination of:
The open-sourcing of GitHub Copilot Chat in VS Code means the community can inspect, improve, and extend this pipeline — a significant step toward collaborative AI development tooling.
Deep Dive: Windows AI Foundry and On-Device AI
Why On-Device AI Matters
Foundry Local (bringing Azure AI Foundry to Windows 11 and macOS) addresses several real problems:
Modern Windows devices with Qualcomm Snapdragon, Intel Core Ultra, or AMD Ryzen AI chips have dedicated NPU hardware designed for exactly this use case. Windows AI Foundry provides the unified API layer that abstracts the underlying silicon, so developers write once and run on any supported hardware.
Deep Dive: Enterprise AI Adoption — Where It Actually Is
The “Keynote in 5” video spends time on enterprise AI adoption data, which provides important context:
These numbers tell a story: the early adopter phase is over. Enterprise AI with Microsoft’s platform is in mainstream adoption. The challenge has shifted from “will this work?” to “how do we scale it safely?” — which explains why governance features like Entra Agent ID and Purview SDK were front and centre at Build 2025.
What Developers Should Build Now
Based on the technologies highlighted in “Keynote in 5”, here are the most technically valuable areas to invest in:
1. MCP Server Development
Build MCP servers that expose your organisation’s internal APIs and data sources. Every MCP server you build makes your systems accessible to any MCP-compatible agent — including GitHub Copilot, Copilot Studio, and any Azure AI Foundry agent.
2. Multi-Agent Workflow Design
Start designing workflows as agent orchestrations rather than monolithic applications. Identify tasks in your codebase or business processes that could be delegated to specialised agents coordinated by Azure AI Foundry Agent Service.
3. On-Device AI Applications with Foundry Local
If you’re building Windows applications, experiment with Foundry Local for latency-critical or privacy-sensitive use cases. The Phi-4-mini model available via Edge AI APIs is a good starting point for embedded AI features.
4. Observability-First Agent Development
Don’t build agents without observability from day one. Use Azure AI Foundry Observability to instrument every agent action — cost, latency, quality, and safety. This data is essential for production-readiness.
Conclusion
The “Keynote in 5: Unpacking the Tech” video earns its place among the top Build 2025 videos because it doesn’t just tell you what was announced — it helps you understand the technical foundations beneath the announcements. MCP, multi-agent orchestration, on-device AI, and autonomous coding agents are not marketing terms. They are engineering realities that are available to build with today.
For developers who want to stay ahead of the curve, understanding these technologies at a deeper level is the difference between following the trend and leading it.
Watch the video: YouTube — Microsoft Build 2025, Keynote in 5: Unpacking the Tech
Tags: Microsoft Build 2025, MCP Model Context Protocol, Azure AI Foundry, Autonomous Agent, GitHub Copilot, On-Device AI, Foundry Local, Multi-Agent Orchestration, Developer Deep Dive
