Weekly .NET Roundup: Agents in IDEs, BYOM, and C# 15 unions

by TechHub

This week in .NET, the tooling story centered on agentic workflows becoming a first-class part of everyday development, with Visual Studio 2026 expanding Copilot into configurable, team-managed agents and adding practical Git upgrades like worktrees and deeper submodule support. Model choice and tool connectivity also tightened up as Bring Your Own Model (BYOM), Model Context Protocol (MCP), and the Microsoft Agent Framework converged into a clearer path from prototype agents to production hosts with observability and governance. On the platform side, C# 15 preview discussions focused on union types (plus closed hierarchies and safety-related changes), while debugging and testing workflows in both Visual Studio and VS Code moved toward tighter loops for reproducing, fixing, and validating failures.

This Week's Overview

Visual Studio 2026 leans further into agentic Copilot (and adds serious Git workflow upgrades)

Building on last week's Visual Studio 18.9 story (submodules moving into the IDE and early Copilot “thinking effort” and local-model workflows), the August Visual Studio 2026 update pushed Copilot beyond inline suggestions and into configurable, team-managed agents. You can now create organization-level custom agents, get better visibility into usage, and manage models directly in the IDE, including “thinking effort” controls that trade speed for deeper reasoning when you need it.

On the source control side, Visual Studio is filling in gaps that used to push teams back to the terminal or another client. Git worktrees make it easier to juggle multiple branches without constant checkout churn, and first-class submodule support is a practical quality-of-life improvement for repos that still depend on nested dependencies.

A separate Copilot-in-Visual-Studio update also highlighted a Git agent that can review changes and commits before you open a pull request. That positions Copilot as a pre-PR quality gate inside the IDE, which is especially useful when you want quick feedback on a local branch before CI and teammate review kick in.

Bring Your Own Model (BYOM), MCP, and the Agent Framework are converging into a .NET agent stack

Following last week's emphasis on making agents governable and operable (from safer tool surfaces to routing and failover patterns), this week connected a lot of dots across Microsoft's agent tooling: Visual Studio is opening up model choice, MCP is becoming the standard way to connect agents to tools and context, and the Agent Framework is getting clearer paths from prototype to production. If you're building internal developer agents or app-specific assistants in .NET, the theme is less “demo” and more “ship it with guardrails.”

Bring Your Own Model (BYOM) in Visual Studio Agent mode (preview)

This extends the local-model thread from last week's Ollama + Copilot-style integrations by making model choice a first-class part of Visual Studio Agent mode. Visual Studio 18.10 Insiders introduced a preview of BYOM for Visual Studio Agent mode, letting you connect to models hosted in Microsoft Foundry/Azure AI Foundry or supported third-party providers like OpenAI, Anthropic, and Ollama. The practical win is that teams can keep the same IDE workflow while switching models per project constraints (cost, latency, data residency) or routing certain tasks to a local model.

It also supports custom endpoints for OpenAI and Ollama, which matters if you run an internal gateway, a self-hosted proxy, or a constrained lab environment. For .NET teams, the takeaway is that “agentic” workflows in Visual Studio are no longer tied to a single model backend, so you can standardize developer experience while still letting platform teams control model policy.

MCP in practice: building servers and grounding agents (including a real-world Uno Platform setup)

Building on last week's agent governance theme (explicit tool boundaries, allow/deny policies, and auditing), Model Context Protocol (MCP) continues to show up as the connective tissue between .NET agents and the systems they need to use safely. A hands-on walkthrough showed how to build an MCP server from scratch with the MCP C# SDK, including defining tools, prompts, and resources, then wiring that server into an agent running in Microsoft Foundry.

A separate case study from Uno Platform showed what “serious” MCP usage looks like: they run two C# MCP servers, one focused on documentation grounding and another that can drive a live app. The interesting detail is the emphasis on verification - using AI not only to propose changes in cross-platform .NET apps, but to validate them via app automation, Roslyn-aware workflows, and Hot Reload loops.

Agent Framework: from loops and multi-agent reviews to production hosting

This week is a clear continuation of last week's “operationalize agents” direction, moving from governance patterns into repeatable runtime behaviors and deployable hosts. Several tutorials focused on repeatable agent behavior and operational readiness. One example built a multi-agent AI code review team in .NET using Microsoft Agent Framework background agents, with specialist roles (security, performance, architecture) coordinated by a lead agent, running locally on Ollama (granite4.1:8b) and emitting OpenTelemetry traces so you can see what happened.

Another video zoomed in on “agent loops”: instead of a single tool call, the agent reruns until a validator says the tool result meets a condition (shown with a LoopAgent and a DelegateLoopEvaluator). This pattern is useful when tool results can be flaky or incomplete and you want deterministic acceptance criteria around the final output.

On the production side, the Agent Harness guidance laid out a structure for taking a single “claw” (an Agent Framework agent) and splitting it into a shared factory plus multiple hosts (console, hosted, evals). It also layered in the parts teams ask for immediately in production: OpenTelemetry observability, Microsoft Purview governance over prompts and responses, Foundry Hosted Agent deployment, and repeatable evaluation workflows.

C# 15 preview: union types headline a broader language push in .NET 11 Preview 7

As a follow-up to last week's .NET 11 Preview 7 coverage, C# 15's union types were the most discussed preview feature this week, framed as a way to model a closed set of unrelated types with strongly typed switching over union values. The key developer impact is cleaner APIs when inheritance hierarchies do not fit, while still keeping pattern matching and exhaustiveness-style benefits in reach.

The broader C# 15 preview (available with .NET 11 Preview 7) included more than union types: closed hierarchies, a preview redesign of unsafe/memory-safety rules, and smaller but practical improvements like collection expression arguments, extension indexers, and labeled break/continue. If you are evaluating .NET 11 previews now, this is a good time to validate how these features affect analyzer rules, team coding standards, and build pipelines (especially if you experiment with the preview compiler in Visual Studio or VS Code).

GitHub Copilot and VS Code: customization, shared agent sessions, and small workflow polish

This continues last week's Copilot workflow theme (better instructions and more flexible model backends) by centralizing configuration and making agent context easier to share across tools and teams. Copilot's weekly notes highlighted a shift toward “make it yours”: the Copilot app's Customize tab is now GA, pulling together configuration for MCP servers, plugins, skills, and canvases. That makes Copilot setup feel less like scattered per-tool configuration and more like a central place to manage how your agents and completions behave across contexts.

Shared agent sessions in Slack and Microsoft Teams also landed, which is a subtle but real workflow change for teams that collaborate in chat-first environments. Instead of pasting snippets back and forth, you can keep an agent session shared in the channel, making it easier to preserve context and decisions.

On the CLI and editor side, Copilot CLI updates included defaults and session restore, reducing friction when you bounce between terminal-driven work and IDE work. VS Code 1.136 Insiders added a tiny but telling UX tweak: the Chat “Artifacts” pill icon now uses a package symbol to better communicate that generated outputs belong to the current session.

Debugging and testing workflows get more agentic (and more integrated)

Building on last week's “agent as part of the everyday dev loop” direction (not just codegen, but governed, observable workflows), Visual Studio's Debugger Agentic workflow added a “Test-Driven Investigation” upgrade that formalizes a common real-world debugging loop: reproduce, isolate, inspect, fix, and rerun. The agent can now create or identify a focused failing test, debug through it (breakpoints, runtime state), and rerun tests to validate the fix and check for regressions, which is a better fit for large .NET solutions than open-ended “try things until it works” debugging.

VS Code also nudged test workflows forward with a short demo of Test Explorer as a front-end for chasing CI failures. The value is pragmatic: jump from a failing CI test to local reproduction, debug inside the editor, and rerun quickly without leaving the IDE.

.NET Conf 2026 sets the timeline for .NET 11 (and points to the previews worth tracking now)

As a natural extension of last week's preview-testing drumbeat around .NET 11 Preview 7, .NET Conf 2026 was announced for Nov 10-12 as a free online event aligned with the .NET 11 launch. The announcement also served as a signpost for what Microsoft expects developers to be exploring ahead of release, with links to previews and deep dives across ASP.NET Core, Blazor, MAUI, C# 15, and tooling.

For planning, the important detail is that this is not just a date on the calendar: it is the natural checkpoint for teams deciding when to validate preview features (language, runtime, and tooling), schedule migration work, and line up training around the incoming platform changes.

Other .NET News

This week's grab bag reinforces a thread from last week: IDE foundations (like VS Code's extensibility) are what make AI features feel integrated rather than bolted on, and the community content keeps filling in practical gaps around EF Core and day-to-day tooling. Amanda Silver shared a useful retrospective on why VS Code's open-source, extension-driven architecture mattered and how that foundation made AI-assisted development feel like a natural evolution rather than a bolt-on. The companion short version focused on the same technical shifts, with an emphasis on how Copilot and cloud services are changing what developers expect from an editor.

Two practical, developer-day-to-day items are worth bookmarking: one guide explains why Environment.ProcessorCount can be misleading on modern systems and provides a cross-platform way to retrieve total logical processors (P/Invoke on Windows/macOS, /sys/devices/system/cpu/online parsing on Linux). Another community standup walks through contributing to Entity Framework Core, including repo setup, codebase layering, and how the test suite is structured, which is a good on-ramp if you want to move from issue comments to real PRs.