Weekly .NET Roundup - Servicing, .NET 11 Preview 6, and VS AI

by TechHub

This week's Weekly .NET Roundup centers on two tracks: staying current with July 2026 servicing updates (including CVE fixes, containers, and known issues) and getting early signal from .NET 11 Preview 6. Mobile teams have a clear action item with .NET MAUI moving to CoreCLR-only on Android, iOS, and Mac Catalyst, while Visual Studio continues to expand Copilot workflows with built-in Agent Skills, model selection, and new extension governance options. We also cover practical modernization and agent operations patterns, from a structured ASP.NET-to-.NET 10 course to OpenTelemetry-instrumented local agents, plus a Durable Functions approach for long-running MCP tools on Azure Functions.

This Week's Overview

July 2026 .NET servicing: stay current on patches and CVEs

Building on last week's reminder to plan around support timelines and keep supported runtimes current, Microsoft shipped the July 2026 servicing releases for both modern .NET and .NET Framework, with updated builds for .NET 10.0.10, .NET 9.0.18, and .NET 8.0.29. The recap centralizes what most teams need during patch week: fixed CVEs (via MSRC references), download links, container images, Linux install instructions, and known-issue callouts.

If you run ASP.NET Core, EF Core, or services built on the .NET runtime, this is the monthly checkpoint to validate your upgrade plan across environments (dev containers, CI images, and production hosts). Teams that standardize on base images should pay extra attention to the container image updates so application images rebuild against patched layers, not just patched app dependencies.

.NET 11 Preview 6 lands, with MAUI moving to CoreCLR-only on mobile

Preview 6 continued the .NET 11 feature runway, and it is also a practical signal for app teams to start compatibility testing now (especially if you ship cross-platform UI or depend on runtime-specific behavior). Alongside the broad preview announcement, the .NET MAUI update this week made the key platform direction explicit: CoreCLR is now the only runtime for .NET MAUI mobile apps in .NET 11 Preview 6.

.NET 11 Preview 6: broad SDK/runtime/library updates to test now

Following last week's .NET 11 preview deep dive (including new C# language shape), the .NET team published .NET 11 Preview 6 with changes spanning libraries, runtime, SDK, C#, ASP.NET Core, EF Core, F#, .NET MAUI, and container images. Even when a preview post summarizes rather than exhaustively lists changes, it is still the best starting point for identifying what to validate: build breaks in CI, behavior changes in System.Text.Json, ASP.NET Core hosting and middleware behavior, NativeAOT readiness, and container baseline shifts.

For teams evaluating .NET 11 adoption, the actionable work this week is to install the Preview 6 SDK in a side-by-side environment and run your full test suite, including integration tests and publish steps (for example, container publishing and dotnet test in CI). The post links to the detailed release notes and the SDK download, so you can drill into your specific stack area rather than treating the preview as a monolith.

.NET MAUI: CoreCLR becomes the only mobile runtime in .NET 11 Preview 6

After last week's focus on MAUI ecosystem readiness (for example, validating graphics stacks like SkiaSharp upgrades in real apps), .NET 11 Preview 6 makes a bigger runtime-level shift for MAUI mobile apps (Android, iOS, and Mac Catalyst): CoreCLR is now the only runtime, and Microsoft is now mapping out the Mono timeline more directly. The update shares current performance expectations and tooling status and explicitly asks developers to test and send feedback ahead of GA, which is a strong hint that real-world app coverage is needed to flush out edge cases.

If you maintain a MAUI app that previously relied on Mono-specific behavior, this is the point to validate startup time, AOT/linking behavior, interop edges, and any runtime reflection-heavy code paths. It is also the right time to re-check your CI and packaging pipeline for mobile, since runtime shifts often show up first as build/publish friction rather than runtime crashes.

Visual Studio expands Copilot workflows: built-in Agent Skills, model picking, and extension governance

Visual Studio updates this week clustered around one theme: giving teams more control over AI-assisted development and the tooling surface it touches. On the developer side, Agent Skills and model management aim to make Copilot-driven work more repeatable and transparent. On the admin side, Private Marketplace preview work targets the governance story for extensions in regulated or tightly managed environments.

Built-in Agent Skills in Visual Studio 18.8 for .NET and Azure tasks

Building on last week's “agent mode in VS Code” onboarding and workflow framing, Visual Studio 18.8 added built-in Agent Skills, which package reusable Copilot capabilities for common .NET and Azure work. The examples span API endpoint tasks, performance review workflows, and Azure deployment chains, with explicit hooks into tools like Azure Developer CLI (azd), infrastructure-as-code options (Bicep and Terraform), Azure Data Explorer queries (Kusto/KQL), and Microsoft Foundry-related tasks.

For teams, the practical benefit is consistency: instead of ad-hoc prompt patterns living in chat history, skills can standardize how developers ask Copilot to do recurring work (review a perf issue, wire an endpoint, or walk a deployment path). The announcement also points to dotnet/skills, which matters if you want to treat skills as code artifacts that can be versioned, reviewed, and shared across a team.

Copilot model picker and usage visibility inside Visual Studio

Visual Studio also added updates aimed at model selection and predictability during longer chats. The model picker work focuses on helping developers compare models by capability (including context window size and vision support), while the UI now surfaces context window and Copilot plan usage so you can see when you are nearing limits.

This is mostly about reducing surprises: if you are debugging something large (logs, stack traces, or multi-file refactors), knowing the effective context window and your plan usage changes how you structure prompts and what you paste into chat. It also encourages teams to document which models to use for which tasks, instead of leaving model choice as a personal preference that produces inconsistent results.

Visual Studio Private Marketplace preview for extension governance

For orgs with compliance requirements, Visual Studio announced a Private Marketplace preview that lets administrators host private extensions and centrally control what is available through the marketplace experience, which lines up with last week's broader theme of making agentic tooling more governable and auditable (not just more capable). The key shift is moving extension availability from an honor system (developers install what they want) to a governed catalog (developers pick from what the org has approved).

If your team depends on internal tooling (custom analyzers, templates, or VS integrations), Private Marketplace can simplify distribution and version control while reducing the risk of unapproved extensions entering regulated environments. It is also relevant for standardizing dev machines and build agents, since extensions often leak into workflow assumptions and project guidance.

Modernization and AI agents: practical patterns for upgrading apps and instrumenting agent workflows

This week connected two “how do I make this real?” problems: modernizing older ASP.NET applications to .NET 10 with concrete artifacts, and building/operating AI agent workflows that are observable and safe. The common thread is operational maturity: repeatable steps, predictable execution, and telemetry you can trust.

Free course: modernize legacy ASP.NET to .NET 10 with the Copilot modernization agent

Pablo Lopes published “.NET Modernization for Beginners”, a free open-source course that walks through upgrading a legacy ASP.NET application to .NET 10 using the GitHub Copilot modernization agent. The course is positioned as a full workflow rather than a single migration step, including assessment and planning artifacts and ending with a deployment to Azure App Service.

For teams staring at legacy debt, the value is the structure: you get an opinionated path that includes what to capture during assessment (so modernization does not become a vague rewrite) and how to turn the end state into a deployable, hosted app. Even if you do not adopt the Copilot agent directly, the artifacts and sequencing can serve as a checklist for your own migration playbook.

Instrumenting and controlling agent tooling with Ollama + OpenTelemetry

This extends last week's push toward agent governance and telemetry (auditing, OpenTelemetry, and safer data access) by showing what the early “inner loop” looks like when you are still running locally. Authorised Territory shared a tutorial on adding console-based tracing to a .NET AI agent harness using an OpenTelemetry trace provider, with Ollama running a local gpt-oss model. The practical takeaway is that agent experiments become much easier to debug when tool calls and internal spans are visible as traces, even before you wire them to a collector and backend.

A second tutorial from the same series demonstrates human-in-the-loop control: the agent requests approval before executing a tool, again using a locally hosted model via Ollama. That pattern matters anytime tool execution has side effects (file writes, network calls, deployments), and it is a straightforward safety mechanism you can implement early while you are still prototyping.

MCP on Azure Functions: handling long-running tool calls with Durable Functions

Following last week's examples of exposing Azure Functions as MCP tools, this week tackles the next problem you hit in production: synchronous tool calls break down when the work is long-running, because many MCP clients assume request/response timing that does not fit minutes-long operations. Lily Ma outlined a common failure mode when building MCP (Model Context Protocol) tools and introduced the MCP Tasks extension, then showed a Durable Functions pattern on Azure Functions that keeps compatibility with today's request/response MCP clients.

The guidance is useful if you are exposing tools that trigger real infrastructure work (indexing, large exports, migrations, or multi-step workflows) but still want to integrate with MCP clients that are not yet fully async-aware. With Python and .NET samples included, the post gives a concrete reference architecture: accept the request, hand off to Durable Functions for orchestration, and return progress or completion in a way the current MCP ecosystem can handle.

Other .NET News

VS Code shipped another Insiders milestone (1.130) with evolving release notes that link out to the commit log and closed issues, which is useful if your extension or tooling workflow depends on upcoming editor behavior. Alongside that, the VS Code team posted a quick “top 5 extensions” roundup for 2026 so far, which is lightweight but can be a prompt to re-check your standard editor setup across a team.

Community standups covered practical tooling in the .NET ecosystem: SQL Database Project Power Tools for improving SQL Database Projects in Visual Studio/SSMS, a .NET + AI check-in on agents and local AI, and a .NET MAUI recap focused on UI work and community contributions. If you rely on these stacks, the videos are a good way to catch smaller workflow improvements that do not always show up as headline features.