Microsoft Build 2026 delivered the most significant GitHub Copilot update since the product launched. Over two days in San Francisco on June 2 and 3, GitHub shipped a desktop app, a new coding model, MCP-powered code review, a redesigned CLI, scheduled agent automations, a generally available SDK, and cloud sandboxes.
Most development teams updated the extension and got back to work. But these announcements signal much more than a feature release, they represent a shift towards AI acting as an active engineering partner rather than just a code completion tool.
This post is for engineering leaders who want to understand what actually changed, why it matters for how their teams build software, and which capabilities are worth prioritising first to improve developer productivity, software quality, and delivery speed.
What Shipped at Build 2026: The Full List
Here is everything GitHub released, grouped by what it does:
Agent infrastructure
- GitHub Copilot app – technical preview, available to Business, Enterprise, Pro, and Pro+ users on Windows, macOS, and Linux
- Cloud and local sandboxes for Copilot – public preview, providing isolated execution environments for agent tool use
- Copilot Memory for Business and Enterprise – user-level preferences in public preview, following earlier rollout to Pro users
- Scheduled automations – Copilot cloud agent can now run on a schedule or respond to repository events without manual input
Models and intelligence
- MAI-Code-1-Flash – Microsoft’s first purpose-built small coding model, rolling out to all Copilot tiers
- Microsoft IQ – generally available across GitHub Copilot, Foundry, and Copilot Studio; a context layer grounding agents in both world knowledge and enterprise knowledge
- Work IQ APIs – generally available June 16; programmatic access to Microsoft 365 intelligence for agent builders
Code review
- MCP support and agent skills in Copilot code review – public preview; brings organisational context into every PR review
- Medium analysis tier – routes complex pull requests to a higher-reasoning model automatically
- Copilot code review for Azure Repos – technical preview for Azure DevOps workflows
Developer tools
- GitHub Copilot SDK – generally available in Node.js, TypeScript, Python, Go, .NET, Rust, and Java
- Copilot CLI redesign – new terminal interface, rubber duck agent, voice input (on-device), and scheduled prompt commands
- Foundry Toolkit for VS Code – generally available; create, debug, and deploy agents from VS Code with trace visualisation
The Three Changes That Actually Move the Needle
Not every update carries equal weight for a working engineering team. These three will have the most direct impact on how work gets done.
1. The Copilot App Changes What Agentic Development Looks Like Day to Day
The GitHub Copilot desktop app is not a reskinned IDE. It is a control centre for running multiple AI agents in parallel, each working in its own isolated Git worktree so they do not interfere with each other.
“From a single My Work view, you can see work in motion across connected repositories: active sessions, issues, pull requests, and background automations.” – Mario Rodriguez, Chief Product Officer, GitHub
The practical shift: instead of a developer directing one Copilot session inside their editor, they can now assign multiple agents to separate issues simultaneously, monitor progress across all of them, review diffs, and open pull requests all from a single desktop interface without switching between tools.
While the agentic shift has made development faster, it has also led to disjointed workflows, more context switching, and too much time spent reviewing agent-generated code. The Copilot app addresses this directly agents, sandboxes, code review, automation, context, and the partner ecosystem coming together as one system.
For engineering leaders: this is the interface that makes parallel agentic development practically manageable rather than theoretically possible. The teams that adopt it early will compress multi-ticket sprint work in ways that sequential single-session development cannot match.
What to do: Add the desktop app to your senior engineers’ workflow this sprint. Run it in parallel with your existing IDE setup for two weeks and measure the change in PR throughput per developer.
2. MCP in Code Review Closes the Context Gap That Has Always Limited AI Review Quality
One of the consistent limitations of AI code review has been context. A reviewer without knowledge of your team’s conventions, your architectural decisions, or your domain-specific constraints produces generic feedback that engineers learn to ignore.
Copilot code review now adapts to your team’s tools and standards and scales its depth to the complexity of each change, with two public previews shipping: agent skills and MCP support that bring your organisation’s context into every review, and a new medium analysis tier that routes complex pull requests to a higher-reasoning model.
This is meaningful. MCP integration means Copilot code review can now draw on your organisation’s own context, conventions, internal tooling, documentation, past review decisions, when evaluating a pull request. The medium analysis tier means complex PRs automatically get more capable model reasoning applied to them, without manual intervention.
For engineering leaders: the value of AI code review has always been proportional to how much context the AI had. That limitation is now addressable.
What to do: Enable MCP support in Copilot code review for your highest-traffic repositories first. Define your team’s agent skills to capture the conventions and standards you want enforced consistently. Measure false-positive review rates before and after.
3. The Copilot SDK Opens Up Custom Agent Building for Internal Tooling
The GitHub Copilot SDK reaching general availability is the most underreported change from Build 2026.
Now generally available in Node.js/TypeScript, Python, Go, .NET, Rust, and Java, the SDK exposes the same agentic runtime that powers the Copilot app. If your team needs an internal code analysis tool, a custom release-notes generator, or an agent embedded in a support workflow, you build it on the same foundation instead of wiring together a bespoke stack.
For teams that have wanted to build internal AI tooling without maintaining a custom infrastructure layer, this removes the primary barrier. The same runtime that powers GitHub’s own agentic features is now available as a stable, production-supported API.
For engineering leaders: think about the repetitive, high-context tasks in your development workflow that a well-designed agent could handle, release note generation, PR description drafting, dependency audit reports, internal documentation updates. The SDK makes these buildable without significant infrastructure investment.
What to do: Identify two or three high-frequency, low-complexity internal workflows that currently require manual effort. Prototype agents for them using the SDK. The build-to-deploy path using the Foundry Toolkit for VS Code is now end-to-end within the Microsoft toolchain.
What to Watch: Copilot CLI Voice Input and Rubber Duck
Two smaller CLI additions are worth noting for teams that work heavily in the terminal.
Voice input runs entirely on-device. Hold the spacebar to dictate a prompt audio never leaves your machine. The rubber duck agent acts as a constructive critic during a session, reviewing the current plan, design, implementation, or tests for blind spots and design flaws, then reporting back with concrete actionable feedback before the main agent continues.
The rubber duck feature in particular addresses one of the recurring failure modes in agentic coding: an agent that is confident but wrong, generating plausible-looking code that misses a design constraint or misunderstands the requirements. A built-in second-opinion layer before code advances is a meaningful quality control addition.
The Pricing Reality Engineering Leaders Need to Know
One context point that matters alongside these capability announcements: Copilot’s June 2026 billing model update has generated developer complaints about unexpectedly rapid AI credit consumption, particularly under usage-based billing for Business and Enterprise tiers.
Before rolling out the new agent features broadly, especially the desktop app and scheduled automations engineering leads should review current Copilot usage patterns and model consumption rates across their teams. The productivity gains are real, but the cost model requires active monitoring.
GitHub has published guidance on managing model usage costs. The Foundry Toolkit’s trace visualisation feature is useful for understanding where token consumption is concentrated in agentic workflows.
The Bigger Picture: From Code Assistant to Development System
The Build 2026 release makes something clear that the individual feature announcements might obscure. GitHub Copilot is no longer a code completion tool. It is becoming the operating layer for how software gets built, managing agents, orchestrating reviews, running background automations, integrating organisational context, and giving developers a unified interface across the full development lifecycle.
The teams that adopt it as a system not a collection of individual features will compound the advantage. The teams that use individual features in isolation will get incremental gains.
At Kilowott, our software and application development practice helps engineering teams design workflows that make the most of modern agentic tooling from Copilot integration to custom agent development using the SDK. If your team is evaluating how to adopt these updates without introducing workflow complexity or billing surprises, we can help with that assessment.
