When an engineer or team creates useful agentic artifacts for their daily work (e.g., instructions, skills, and MCP configurations), others naturally want to adopt them when they see how those artifacts could help with their own work. Sharing the files is straightforward, but keeping those consumers supplied with fixes, updated guidance, and compatible tool configurations requires a way to maintain and distribute those artifacts.

That challenge shaped our work with a large enterprise customer as we designed and built a migration and modernization toolkit together. Their internal and third-party engineering teams needed a consistent way to apply the customer’s architecture guidance, tools, and delivery practices while modernizing thousands of applications. We packaged and distributed those capabilities through GitHub Copilot plugins, and we’ll walk through the choices we made, the trade-offs behind them, and how you can adapt the approach to your own engineering workflows.

This work applied platform engineering practices to AI-assisted engineering workflows. We maintained shared capabilities as a versioned toolkit that teams could install in their existing development environments, while keeping application-specific context and decisions in their repositories.

Making adoption and updates manageable

We needed to distribute these artifacts together, with a way for maintainers to release changes and engineers to adopt them. Copying files into each application repository would leave teams responsible for reconciling shared updates with their local changes. GitHub Copilot plugins gave us an installable, versioned package for those artifacts.

We also wanted to avoid building and maintaining our own mechanism for packaging and loading these artifacts. Using Copilot’s existing plugin support let us focus on the toolkit’s content and release practices. Its support for the open Agent Plugins specification also provides a path to reuse skills and MCP configurations across compatible clients, while custom agents and hooks depend on client-specific support.

The engineering teams typically use VS Code and GitHub Copilot CLI, both of which support Copilot plugins. That let us bring the toolkit into familiar clients instead of requiring each team to assemble the configuration independently. Packaging and catalog publication are also separate, so maintainers can develop a plugin before listing it in an internal marketplace.

Versioning was another important requirement. We needed identifiable releases so that, when an engineer reported a problem, we could establish which version they were using and investigate the corresponding configuration and instructions. Including the installed version in a bug report provides that context without assuming centralized visibility into every installation. Versioned releases also provide a basis for testing updates before wider adoption and planning a return to a known working version. A rollback plan still needs retained releases and a verified recovery procedure for the client and installation source in use.

Deciding what belongs in the plugin

With the package format chosen, we needed to select the content teams would install together. We focused on artifacts that supported recurring engineering tasks across application repositories and that we could maintain as shared guidance or configuration. The customer’s migration constraints, agent instructions, and tool connections belonged in that shared package. Application-specific evidence and decisions needed to remain with the teams responsible for those applications.

Consider an engineer preparing a migration plan. The plugin supplies the planning agent’s instructions, a migration-context skill with the program’s constraints and terminology, and MCP configuration for the tools the workflow uses. Bundling those pieces lets maintainers release changes to the workflow together and saves each team from assembling the same guidance and connections independently.

The application repository supplies the other half of that example: the source code, existing documentation, and service-specific decisions needed to make the plan useful. The resulting migration plan also stays there, so the team can review and evolve it alongside the application. Credentials and access come from the consumer’s environment. Distributing a tool connection’s configuration does not grant access to the system behind it.

This boundary gives maintainers a shared release to support while leaving application context under each team’s ownership. It also keeps independently maintained resources in their existing homes: approved architecture templates retain their own repositories and release history, with the skill referencing their source. The trade-off is that installing the plugin provides the reusable workflow, but teams still need the application context, referenced resources, and authorized tool access to use it.

Helping teams discover, install, and update

Distribution did not require a separate hosting service. A Git repository containing the plugin artifacts and manifests was enough to make the package available to authorized consumers through supported clients. We hosted ours in an internal GitHub repository, using a fork of devsquad-copilot as the foundation for the toolkit, and maintained the package through the same pull request and release practices used for other engineering work.

The plugin’s plugin.json manifest describes the package, while the marketplace’s marketplace.json lists the sources and metadata of packages available through the catalog.

Maintainers publish a catalog entry by registering the plugin in the marketplace manifest. Plugins can also be installed directly from a repository, so leaving one out of the marketplace controls its visibility there, not repository access or all installation paths.

Engineers register the internal marketplace in their client and install the packages relevant to their work. The GitHub Copilot CLI plugin reference and VS Code plugin documentation describe the client-specific discovery, installation, and update steps. Consumers still need repository access, an authorized Copilot setup, and the credentials, network access, and runtimes required by the configured tools.

Publishing a release did not mean every team adopted it immediately. An update might change the planning agent’s instructions. A team that installs it receives the revised guidance, while another still uses the previous version. If those teams report different behavior, the installed plugin version becomes one detail to check. Update behavior depended on the client’s settings and the package source, so publishing a release did not guarantee that every team was using it.

How the components support engineering work

Recurring migration and modernization tasks shaped the toolkit’s components. The customer’s architecture guidance provided the starting point, and the packaged components helped engineers and agents apply it to individual applications. Teams could use the capabilities relevant to their work without adopting the entire delivery process.

The plugin included a migration specification template to support teams adopting spec-driven development. It covered the current system, intended target, dependencies, test scenarios, success criteria, and rollback expectations. Engineers could refine that specification as implementation revealed new constraints or changes in scope. An accompanying architecture decision record template helped capture choices and their rationale. The templates traveled with the plugin, while the resulting documents stayed with the application code.

Working with unfamiliar code also required reliable navigation. We paired a session-start hook that checked for user-level or project-level Language Server Protocol (LSP) configuration with a skill that guided language-server setup in the development environment. The public lsp-setup skill illustrates this setup approach. Configuration alone did not establish readiness, so engineers still needed to confirm that navigation worked in their client.

For application-specific modernization work, we connected the relevant agents to the GitHub Copilot App Modernization MCP Server through the Model Context Protocol (MCP). Its tools supported Java repository assessment, upgrade planning, modernization tasks, builds, tests, dependency vulnerability checks, and migration consistency checks.

Applying the customer’s Azure architecture choices required current technical inputs. Azure MCP provided deployment guidance, pricing information, Bicep schemas, and Terraform practices, along with tools for examining policy and access controls. Microsoft Learn MCP supplied official documentation and code samples that agents could consult when implementing or reviewing an approved integration pattern.

Packaging those connections alongside customer-specific instructions gave teams a shared way to bring architecture guidance, application context, and implementation tools into the same workflow.

Ownership and governance

The toolkit had to coexist with customizations in application repositories and engineers’ personal environments, so we chose distinctive agent and skill names to reduce collisions with local definitions. In Copilot CLI, a project-level agent with the same identifier could take precedence over the packaged version, leaving an engineer running local instructions after installing an update. MCP server configurations needed separate consideration because their loading rules differ.

Alongside naming, each agent’s configuration defined the tools available for its role. Explicit tool lists made that access visible during review and reduced the chance that adding an integration would unintentionally expand an agent’s capabilities. Model selection remained with the consumer or administrator within enterprise policy, allowing teams to evaluate newly available models without requiring a toolkit release just to change a pinned model choice.

These configuration decisions were part of maintaining the toolkit as a shared engineering product, supported by a roadmap, issue backlog, contributions, and releases. Through the inner-source contribution process, internal and third-party engineers could propose improvements for architecture owners to review, helping distinguish reusable changes to shared guidance from decisions that belonged with individual applications.

Find your starting point

Look for recurring workflows where teams assemble the same instructions, references, or tool connections, and choose one as a starting point for a shared plugin. Invite other teams to use it in their own work and share where it fits their needs or requires adjustment.

Use that feedback to refine both the package and the way it is maintained, with clear ownership, a process for releasing updates, and a path for consumers to contribute improvements. As additional workflows become candidates for sharing, apply those lessons to the next plugin so the collection grows around demonstrated needs.

Further reading

• GitHub Copilot plugins: An introduction to plugins and the customizations they bundle.
• Agent Plugins specification: The portable package format, manifest, component discovery, and client-extension requirements.
• Agent Plugins specification: future considerations: Open questions and areas outside the current specification, including permissions, secret handling, and enterprise policy.
• Agent plugins in VS Code: Supported formats, marketplace installation, updates, and cross-client compatibility.
• Copilot CLI plugin reference: Plugin and marketplace commands, configuration, and loading precedence.
• devsquad-copilot: The open-source framework we used as the foundation for the customer toolkit.
• GitHub Copilot App Modernization for Java: The upgrade and migration tooling used in the program’s Java workflows.

The post Enabling Consistent AI-Assisted Engineering with GitHub Copilot Plugins appeared first on Microsoft for Developers.

Progress Telerik UI for Blazor has a slew of components available for file uploads and management capabilities in your app. See which one is right for your app.

One of the critical tasks in the world of software development is uploading and managing files. Although it may seem trivial, the needs of each application vary. From a button to select a single file to integrating a PDF file viewer, Progress Telerik UI for Blazor provides a set of specialized controls for this task. In this article, let’s examine the components created for this purpose so you have a better view of which to choose for your specific use case. Let’s get started!

The Blazor FileSelect Component

Let’s talk first about the Blazor FileSelect component, which is useful when you want a user to select one or several files and process them in memory or on the server. After the files have been selected, we obtain the stream for each file, which allows us to process them as we see fit.

This component is ideal, for example, if you need to validate files before uploading them, or when you want to process them in memory to display charts or interactive controls.

Some of the advantages of using the component are that it has built-in native validations that help configure a set of allowed extensions, as well as limit file size. Another feature is that it is possible to show preloaded files when the component renders, useful when you want to show the user the last files they selected or to store some kind of state in your application.

An example of using the component is shown below:

@page "/fileselect"

<PageTitle>FileSelect | Telerik Blazor</PageTitle>

<h1>FileSelect</h1>

<div class="demo-panel">
    <TelerikFileSelect Multiple="true"
                       AllowedExtensions="@allowedExtensions"
                       OnSelect="OnSelect"
                       OnRemove="OnRemove" />
</div>

<p class="demo-status">@status</p>

@if (selectedFiles.Count > 0)
{
    <ul class="demo-list">
        @foreach (var file in selectedFiles)
        {
            <li>@file</li>
        }
    </ul>
}

@code {
    private readonly List<string> selectedFiles = [];
    private readonly List<string> allowedExtensions = [".pdf", ".txt", ".png", ".jpg"];
    private string status = "Select one or more files. FileSelect does not upload them to the server.";

    private void OnSelect(FileSelectEventArgs args)
    {
        selectedFiles.Clear();
        selectedFiles.AddRange(args.Files.Select(file => file.Name));
        status = $"Selected: {args.Files.Count} file(s).";
    }

    private void OnRemove(FileSelectEventArgs args)
    {
        foreach (var file in args.Files)
        {
            selectedFiles.Remove(file.Name);
        }

        status = selectedFiles.Count == 0 ? "No files selected." : $"{selectedFiles.Count} file(s) remaining.";
    }
}

In the above code, you can notice that a list of files is managed, which are processed thanks to the events OnSelect and OnRemove as shown below:

Without a doubt, a component tailored to the needs of the .NET environment for file selection.

The Blazor Upload Component

The second component ideal for when we want to upload files is Blazor Upload. This component is very similar to Blazor FileSelect, with the difference that it was created to upload files from a local system to a web server. The component allows users to make asynchronous HTTP requests to the endpoints configured via the parameters SaveUrl and RemoveUrl, allowing uploading and deleting files.

The great advantage of this component is that it provides all the logic to perform file uploads to ASP.NET Core controllers that accept IFromFile. It lets us handle progress, perform basic client-side validation, supports drag and drop, among other features. Additionally, it is possible to configure whether to start the upload automatically or wait for the user to perform an action, such as pressing a button for this purpose.

To show its use, I have defined a couple of minimal APIs in Program.cs to save and delete files:

var builder = WebApplication.CreateBuilder(args);
...
var app = builder.Build();
...
var uploadsPath = Path.Combine(app.Environment.ContentRootPath, "App_Data", "uploads");
Directory.CreateDirectory(uploadsPath);

app.MapPost("/api/files/save", async (HttpRequest request) =>
{
    var form = await request.ReadFormAsync();
    
    foreach (var file in form.Files)
    {
        var fileName = Path.GetFileName(file.FileName);
        var destination = Path.Combine(uploadsPath, fileName);

        await using var output = File.Create(destination);
        await file.CopyToAsync(output);
    }

    return Results.Ok(new { uploaded = form.Files.Count });
}).DisableAntiforgery();

app.MapPost("/api/files/remove", async (HttpRequest request) =>
{
    var form = await request.ReadFormAsync();
    var fileNames = form["files"].Concat(form["fileNames"]);

    foreach (var fileNameValue in fileNames)
    {
        var fileName = Path.GetFileName(fileNameValue);

        if (string.IsNullOrWhiteSpace(fileName))
        {
            continue;
        }

        var filePath = Path.Combine(uploadsPath, fileName);

        if (File.Exists(filePath))
        {
            File.Delete(filePath);
        }
    }

    return Results.Ok();
}).DisableAntiforgery();

app.Run();

On a new page, we can implement the Upload component as follows:

@page "/upload"

<h1>Upload</h1>

<div class="demo-panel">
    <TelerikUpload SaveUrl="/api/files/save"
                   RemoveUrl="/api/files/remove"
                   Multiple="true"
                   AllowedExtensions="@allowedExtensions"
                   OnSelect="OnSelect"
                   OnSuccess="OnSuccess" />
</div>

<p class="demo-status">@status</p>

@code {
    private readonly List<string> allowedExtensions = [".pdf", ".txt", ".png", ".jpg"];
    private string status = "Select files to upload them to the server.";

    private void OnSelect(UploadSelectEventArgs args)
    {
        status = $"Preparing {args.Files.Count} file(s).";
    }

    private void OnSuccess(UploadSuccessEventArgs args)
    {
        status = $"Upload completed for {args.Files.Count} file(s).";
    }
}

In the previous code, you can see that the TelerikUpload component is configured with both the SaveUrl and RemoveUrl properties. The SaveUrl property points to the server endpoint responsible for saving uploaded files, while the RemoveUrl property specifies the server endpoint used to delete files.

Together, these properties allow the component to manage file upload and removal operations through server-side methods.

The result of the above execution is the following:

Although the visual behavior of the Upload and FileSelect components is similar, the first is ideal for files that must be received by a controller, while the second is ideal for WebAssembly-based applications if you want to receive and manipulate files directly in the browser.

The DropZone Component for Blazor

If you need a dedicated area where users can drag and drop their files linked to an existing FileSelect or Upload, you can use the Blazor DropZone component. When users drop files onto the area, processing will start automatically.

One of the great advantages of this component is that it allows you to fully customize the appearance of the displayed files. Here is an example of its use, considering the implementation of the endpoints used in the previous section:

@page "/dropzone"

<h1>DropZone</h1>

<div class="demo-panel">
    <TelerikDropZone Id="upload-dropzone"
                     HintText="Drag files here"
                     NoteText="The Upload below uses this external drop zone." />
    
    <TelerikUpload SaveUrl="/api/files/save"
                   RemoveUrl="/api/files/remove"
                   DropZoneId="upload-dropzone"
                   Multiple="true"
                   OnSuccess="OnSuccess" />
</div>

<p class="demo-status">@status</p>

@code {
    private string status = "Ready to receive files.";

    private void OnSuccess(UploadSuccessEventArgs args)
    {
        status = $"Operation completed for {args.Files.Count} file(s).";
    }
}

In the code above, you can see how the TelerikDropZone component specifies a Id, which must be used in the Upload or FileSelect component via the DropZoneId parameter, in addition to controlling whether multiple uploads will be allowed through the Multiple parameter. The result is the following:

In the image above we can see that the component is geared toward providing a better user experience.

The Blazor File Manager Component

If you need a higher degree of customization for file management, the Telerik suite offers the Blazor FileManager component, which is an explorer-like control that allows browsing, viewing and managing files or folders. This component is very useful when you require applications with full control over file handling and a set of features for actions such as creating, sorting, searching or uploading.

It also supports drag-and-drop operations, executing actions via a context menu and even a customizable toolbar to add the best tools for your use case.

One thing to keep in mind is that the component supports two ways of providing data to the FileManager component, which are Flat data and Hierarchical data. In the first approach all items are in a single collection, while in hierarchical mode each folder contains a collection of children. To see it in action, we can define a class called DemoFileEntry:

public class DemoFileEntry
{
    public string Id { get; set; } = Guid.NewGuid().ToString();

    public string? ParentId { get; set; }

    public string Name { get; set; } = string.Empty;

    public long Size { get; set; }

    public string Path { get; set; } = string.Empty;

    public string Extension { get; set; } = string.Empty;

    public bool IsDirectory { get; set; }

    public bool HasDirectories { get; set; }

    public DateTime DateCreated { get; set; } = DateTime.Now;

    public DateTime DateCreatedUtc { get; set; } = DateTime.UtcNow;

    public DateTime DateModified { get; set; } = DateTime.Now;

    public DateTime DateModifiedUtc { get; set; } = DateTime.UtcNow;

    public List<DemoFileEntry> Items { get; set; } = [];

    public List<DemoFileEntry> Directories { get; set; } = [];
}

In the model above, we have the lists Items and Directories within the same class, which allows us to recognize a Flat data approach. On the other hand, the component would look like the following:

@page "/file-manager"
@using System.IO
@using TelerikFileManagementTests.Models

<PageTitle>File Manager | Telerik Blazor</PageTitle>

<h1>File Manager</h1>

<div class="demo-filemanager-nav">
    <TelerikButton Icon="@SvgIcon.Home"
                   Title="Home"
                   Enabled="@CanGoUp"
                   OnClick="GoHome" />
    <TelerikButton Icon="@SvgIcon.ChevronUp"
                   Title="Up one level"
                   Enabled="@CanGoUp"
                   OnClick="GoUp" />
    <span>@DisplayPath</span>
</div>

<div class="demo-panel demo-panel-wide">
    <TelerikFileManager TItem="DemoFileEntry"
                        @ref="fileManager"
                        Data="@visibleItems"
                        Height="520px"
                        Path="@currentPath"
                        PathChanged="OnPathChanged">
        <FileManagerToolBar>
            <FileManagerToolBarSortTool />
            <FileManagerToolBarSortDirectionTool />
            <FileManagerToolBarFileViewTool />
            <FileManagerToolBarSpacer />
            <FileManagerToolBarSearchTool />
        </FileManagerToolBar>
    </TelerikFileManager>
</div>

<p class="demo-status">Current path: @DisplayPath</p>

@code {
    private TelerikFileManager<DemoFileEntry>? fileManager;

    private string currentPath = string.Empty;

    private List<DemoFileEntry> visibleItems = [];

    private readonly List<DemoFileEntry> allItems =
    [
        new()
        {
            Id = "Documents",
            Name = "Documents",
            Path = "Documents",
            IsDirectory = true,
            HasDirectories = false,
            DateCreated = DateTime.Today.AddDays(-14),
            DateCreatedUtc = DateTime.UtcNow.AddDays(-14),
            DateModified = DateTime.Today.AddDays(-2),
            DateModifiedUtc = DateTime.UtcNow.AddDays(-2)
        },
        ...
    ];

    protected override void OnInitialized()
    {
        RefreshVisibleItems();
    }

    private async Task OnPathChanged(string path)
    {
        await NavigateTo(path);
    }

    private Task GoHome()
    {
        return NavigateTo(string.Empty);
    }

    private Task GoUp()
    {
        if (!CanGoUp)
        {
            return Task.CompletedTask;
        }

        var parentPath = Path.GetDirectoryName(currentPath) ?? string.Empty;

        return NavigateTo(parentPath);
    }

    private async Task NavigateTo(string path)
    {
        currentPath = path;
        RefreshVisibleItems();

        await InvokeAsync(() => fileManager?.Rebind());
    }

    private void RefreshVisibleItems()
    {
        var parentId = allItems
            .FirstOrDefault(item => item.IsDirectory && item.Path == currentPath)
            ?.Id;

        visibleItems = allItems
            .Where(item => item.ParentId == parentId)
            .ToList();
    }

    private bool CanGoUp => !string.IsNullOrWhiteSpace(currentPath);

    private string DisplayPath => string.IsNullOrWhiteSpace(currentPath) ? "/" : currentPath;
}

There are some important points to highlight from the code above:

• Use TItem="DemoFileEntry" to indicate the data type that will be used to represent files and folders.
• The FileManagerToolBar section is used to specify the tools available in the toolbar.
• We create and initialize a list allItems to create the demo’s mock folders and documents.
• We handle some useful parameters when a change occurs, such as PathChanged and OnRead.

When running the application, we can see a nice graphical interface that allows file management in an easy way:

In the image above you can see the component in action, noting native features that can greatly help users, as well as a context menu to perform actions on the file.

The Blazor PDF Viewer Component

The last component we’ll discuss is the Blazor PDF Viewer. Although this component is different from the previous ones, it is very useful for integrating a PDF file viewer into your own application. The component includes functionalities such as showing pagination, zooming, printing, text search, among other features.

To integrate it into a Blazor application, you must load a PDF document as part of the viewer. In the following example, we read a document from the previously created uploads folder, from which we extract the byte array as follows:

@page "/pdf-viewer"

@using Microsoft.AspNetCore.Hosting

@inject IWebHostEnvironment Environment

<h1>PDF Viewer</h1>

<div class="demo-panel demo-panel-wide">    
    <TelerikPdfViewer Data="@pdfData"
                      Height="700px"
                      Width="100%" />
</div>

@code {
    private byte[] pdfData = Array.Empty<byte>();

    protected override async Task OnInitializedAsync()
    {
        var filePath = Path.Combine(Environment.ContentRootPath, "App_Data", "uploads", "Blazor Drawer Overview.pdf");
        pdfData = await System.IO.File.ReadAllBytesAsync(filePath);
    }
}

You can see how in the previous code the TelerikPdfViewer component is used to configure the data source for the PDF document, as well as the height and width. This only shows a small part of the component’s configuration options. When tested, it appears as follows:

Without a doubt, the PDF Viewer component is an excellent option for having control over the PDF files displayed in your application.

Conclusion

Throughout this article, we have taken a tour of the Telerik components for Blazor that allow uploading and managing files. You have seen how each of them works and confirmed that there is a component for every use case, from simple scenarios where a single button is needed to select files, to a complete file manager to precisely control the options available for each.

I encourage you to try them out and enhance your users’ experience by adding them to your projects. The whole suite of components is available to try free for 30 days.

Try Now

The best LLM in Visual Studio is the one you choose. This month’s update puts that idea front and center: pick the model that fits how you work, then use it everywhere GitHub Copilot already helps you today, from fixing vulnerable packages to reviewing pull requests. And once you’re in the editor, you’ll find sharper debugging tools too, whichever model is doing the thinking alongside you.

Grab the Visual Studio 2026 Stable Channel update and let us know what’s working and where we should invest next.

Updates to Bring Your Own Model

The best AI in Visual Studio is the AI you can bring with you. With Bring Your Own Model (BYOM), more developers can use AI in Visual Studio with the models their teams prefer, whether through GitHub Copilot or their own model deployments. From individual developers experimenting with new models to organizations standardizing on approved deployments, BYOM lets you use AI your way, whether or not you’re signed in to GitHub.

BYOM is available in preview and enabled by default across the Community, Professional, and Enterprise SKUs. Connect to a Microsoft Foundry deployment or another supported provider, including custom endpoints for OpenAI and Ollama, then work in Agent Mode with the new Agent (Preview).

This is an early preview, and we want your feedback. Not every model supports every Agent Mode capability yet. When a feature isn’t supported, Visual Studio marks it clearly instead of failing silently. Try it and tell us what’s working and where we should invest next in the Developer Community forum or fill out this short survey.

To get started: open Chat, open the model picker and choose Add a model or Manage Models, connect to your provider, then start working in Agent Mode. Supported providers are Microsoft Foundry, OpenAI, Anthropic, and Ollama, with custom endpoint support for OpenAI and Ollama.

This release has breaking changes for the BYOM capability: BYOM now works with the new Agent (Preview), which is built on the GitHub Copilot SDK-powered harness. The earlier BYOM experience in the previous Ask and Agent modes is no longer supported; install the latest Visual Studio release and use the new Agent (Preview) to try it. Previously added Ollama models will need to be re-added after this update due to a few backend updates for that provider.

Fix NuGet Vulnerabilities from the Error List

Whichever model you’ve chosen, it can now help you close security gaps the moment they surface. NuGet Audit warnings in the Visual Studio Error List give you a direct way to fix vulnerable packages with GitHub Copilot instead of tracking them down manually.

After a restore reports an NU1901, NU1902, NU1903, or NU1904 warning, select the sparkle action in the Fixer column. This opens GitHub Copilot Chat in agent mode and asks Copilot to fix the vulnerable NuGet packages using the NuGet MCP server.

To use the fix: restore a solution that contains a package with a known vulnerability, open View > Error List and find the NuGet Audit warning, select the sparkle action in the Fixer column, then review and apply the changes Copilot proposes. You’ll need to be signed in to GitHub Copilot, and automated fixes also require the NuGet MCP server, which is built into Visual Studio and can be enabled from the Copilot Chat tools menu.

Explore Pull Requests with the Git Agent

Reviewing a pull request usually means piecing together the discussion thread, the changed files, and what actually matters before you can dig in. The Git agent can now do that legwork for you, powered by whichever model you’ve connected.

Open GitHub Copilot Chat, select the Git agent, and ask it about your pull request, attaching the pull request as context from the Git Repository window. The response includes navigable links that open the corresponding comments and files directly in the pull request view in the IDE, so you can jump straight to what matters instead of scrolling to find it. Ask follow-up questions any time you want the agent to go deeper.

Connect your Git provider’s MCP servers so Copilot can pull in more context about your pull requests. GitHub and Azure DevOps are both supported.

See Which Operand Decides Your if Condition

Ever paused on a compound if statement and had to work out which part of it actually made the call? Visual Studio now highlights the deciding expression in C# if statements that use && or ||.

While debugging, pause on an if statement. Alongside the existing inline → true or → false hint, Visual Studio uses red and green highlighting to show which operand determined the result. When an && condition evaluates to false, the highlighting identifies the operand that failed or caused evaluation to short-circuit. When an || condition evaluates to true, it identifies the operand that satisfied the condition. It’s a small detail that saves you from mentally evaluating each piece of a complex branch on your own.

You can right-click a highlighted expression to disable branch highlighting from the editor context menu, and the highlight colors are available under Tools > Options > Environment > Fonts and Colors if you want to tune them to your theme.

Attach to Process Now Supports Podman Containers

Container discovery now recognizes Podman alongside Docker. Start a container, then go to Debug > Attach to Process. Set Connection type to Podman, then select Find. Your Podman containers appear automatically, with the same attach experience you already use for Docker.

You can debug both .NET and C++ containers with no extra configuration.

From our entire team, thank you for choosing Visual Studio! For the latest updates, resources, and news, check out the Visual Studio Hub and stay in touch.

Happy coding! The Visual Studio team

The post Visual Studio September Update – Power Your Workflow with Your Model appeared first on Visual Studio Blog.

Essential Studio 2026 Volume 3 at a glance

The Essential Studio 2026 Volume 3 expands the Syncfusion toolkit across AI, document processing, forms, UI development, and collaboration. Here are the updates worth exploring.

Release highlights

• JavaScript libraries for Excel and PowerPoint.
• .NET Document Chunking Library for AI and retrieval workflows.
• A2UI for dynamically generated user interfaces.
• WebMCP integration for connecting Syncfusion components with AI assistants.
• Form Builder and Form Renderer for dynamic forms.
• AI-powered PDF experiences.
• New UI controls across .NET MAUI, Pure React, Blazor, and WinUI.
• Collaboration capabilities for documents and spreadsheets.

New AI and AI-ready capabilities

Volume 3 introduces new ways to prepare enterprise content for AI retrieval, generate interfaces dynamically, connect AI assistants with web components, and add intelligent PDF experiences.

Prepare enterprise content for RAG with document chunking

Building a retrieval-augmented generation (RAG) or semantic-search application often starts with preparing documents for retrieval.

The new .NET Document Chunking Library (Preview) transforms PDFs, Word documents, Excel workbooks, PowerPoint presentations, and Markdown files into context-aware chunks while preserving document structure and metadata.

Developers can preserve document hierarchy, control chunk size and overlap, and retain metadata and citations, providing structured content for RAG, semantic search, and knowledge-retrieval workflows.

Create dynamic interfaces with A2UI

AI applications often need more than text responses. They may need forms, charts, grids, or other interactive experiences based on a user’s request.

With A2UI (Preview) for Blazor, React, Angular, Vue, and .NET MAUI, AI agents can dynamically generate interactive user interfaces using Syncfusion components. A2UI components provide the building blocks for these interfaces, while the new A2UI Composer provides a visual way to design and refine them.

Agents describe the interface they need, while the application controls how it is rendered. This enables adaptive experiences such as AI-generated forms, grids, charts, and schedulers without requiring the agent to generate the complete UI implementation.

Connect components with AI Assistants using WebMCP

WebMCP enables AI assistants to interact with Syncfusion React, Angular, JavaScript, JavaScript (ES5), and Vue components through natural language, with component capabilities exposed as tools. Developers can control tool exposure through selection, custom prefixes, and access restrictions.

Build intelligent PDF experiences

The Smart .NET MAUI PDF Viewer adds AI-powered capabilities for applications that work extensively with PDF documents. It can extract document information, detect and populate form fields, redact sensitive content, and connect to custom AI services, helping automate common PDF workflows.

Create Excel and PowerPoint files with JavaScript

Essential Studio 2026 Volume 3 introduces JavaScript Excel and PowerPoint Libraries (Preview) for browser and Node.js applications. These libraries allow developers to create and process Office documents programmatically without requiring Microsoft Office installations.

• JavaScript Excel Library: Create and edit workbooks with formulas, ranges, charts, tables, validation, protection, and programmatic formatting.
• JavaScript PowerPoint Library: Generate presentations programmatically with layouts, master slides, charts, tables, images, shapes, sections, and speaker notes.

Together, these libraries extend JavaScript-based document workflows for creating and processing Excel and PowerPoint files.

Build dynamic forms with Form Builder and Form Renderer

The new Form Builder (Preview) provides a visual drag-and-drop experience for designing dynamic forms. It includes 20+ controls, conditional logic, dependent fields, calculated expressions, validation, and schema generation.

Once a form is designed, Form Renderer (Preview) renders responsive forms directly from JSON schemas.

Together, Form Builder handles visual form creation while Form Renderer turns the resulting schema into a responsive runtime form. They can support onboarding processes, approval processes, surveys, and other form-driven business applications.

New UI controls across platforms

Volume 3 expands the UI library across .NET MAUI, Pure React, Blazor, and WinUI.

.NET MAUI

Volume 3 introduces five .NET MAUI controls:

• Diagram for flowcharts, process designers, visual editors, and organizational charts.
  

  

• TreeGrid for hierarchical data in a grid interface.
  

  

• Interactive Viewer for zooming, panning, and rotating content.
  

  

• Grid Splitter for resizable application layouts.
  

  

• Data Pager for navigating large datasets.
  

  

Pure React

Pure React gains new File Upload, Sidebar, and TreeView components for file processing, navigation, and hierarchical data, respectively.

Blazor Sunburst Chart

The new Blazor Sunburst Chart(Preview) visualizes multilevel hierarchical data through concentric rings, with drill-down, selection, highlighting, theming, and tooltip support.

WinUI Docking Manager

The new WinUI Docking Manager (Preview) supports docked, floating, tabbed, and auto-hidden windows for building flexible desktop workspaces.

Key enhancements across existing components

Beyond the new controls and libraries, 2026 Volume 3 includes enhancements across existing web, Blazor, .NET MAUI, document, and desktop products.

Here are some notable updates.

Web components [React, Angular, Vue, JavaScript, ASP.NET Core, ASP.NET MVC]

• Charts: Cartesian Charts add smart data labels to reduce overlaps, while Stock Charts improve live updates, navigation synchronization, and streaming behavior.
• DataGrid: The DataGrid adds formula cells, advanced filtering, and automatic row numbering, extending spreadsheet-like interaction for business data.
• Gantt Chart: The Gantt Chart gains flexible scheduling, drag-to-create tasks, dependency restrictions, synchronized numbering, and improved hierarchical selection.
• TreeGrid: TreeGrid adds DOM virtualization for large hierarchical datasets along with enhanced parent-child selection modes.
  

  

• File Manager: File Manager adds more control over folder behavior during drag-and-drop operations.
• Modern Rich Text Editor: The Modern Rich Text Editor delivers a modern, extensible WYSIWYG experience for structured content, with ProseMirror providing the underlying document model and editing engine.
• Headless Editor: The Headless Editor is a framework-agnostic editing foundation built on ProseMirror for modern rich-text and structured editing. It provides a modular architecture with extensible commands, extensions, schemas, NodeViews, events, and reusable editing services.

Blazor components

Blazor updates span AI experiences, data interaction, project planning, and barcode support.

• Inline AI Assist is now production-ready, enabling contextual AI-assisted interactions within Blazor applications.
• Barcode Generator adds GS1 Linear, GS1 QR Code, GS1 DataMatrix, and DotCode support.
• Gantt Chart adds task constraints, multiple event markers, weekend controls, configurable view dates, and MemoryStream export.
• DataGrid adds Excel-style editing, undo and redo, find and highlight, event-driven data binding, and custom printing.

.NET MAUI Controls

Existing .NET MAUI controls also receive several notable upgrades.

• Rich Text Editor is now production-ready.
• Cartesian Charts add gradient line series, improved trackball interactions, annotation layering, and axis styling.
• Scheduler adds hierarchical resources, appointment-overlap restrictions, month agenda view, and ICS import and export.
  

  

Document solution enhancements

Document SDK

The 2026 Volume 3 release extends document generation, conversion, extraction, rendering, and security across the Document SDK.

• JavaScript PDF Library adds PDF encryption, signature validation, text search, image markers, and annotation enhancements.
  

  

• .NET PDF Library adds SVG-to-PDF conversion along with updated Blink binaries.
• .NET Excel, Word, and PowerPoint Libraries gain improvements across custom fonts, SVG support, Markdown conversion, rendering, signatures, and validation.
• .NET Data Extraction Library adds PDF-to-Word and PDF-to-HTML conversion along with barcode and QR-code recognition.

PDF Viewer SDK: Collaboration, comparison, and AI

The PDF Viewer SDK receives updates across Web, Blazor, and .NET MAUI.

Highlights include collaborative editing, semantic PDF comparison, AI-powered form-field processing, digital signatures, annotation improvements, thumbnail navigation, and document modification tracking.

• Web PDF Viewer: The Web PDF Viewer adds real-time collaboration and semantic text comparisons for identifying document changes.
  

  

• Blazor PDF Viewer: The Blazor PDF Viewer adds AI-powered form-field detection and data extraction for scanned and image-based PDFs.
• .NET MAUI PDF Viewer: The .NET MAUI PDF Viewer adds digital signatures, thumbnail navigation, and document modification tracking.

Better collaborative document experiences

DOCX Editor SDK

The Web and Blazor DOCX Editor SDK improves collaborative review with author-based comment highlighting and customizable colors for tracked changes.

Spreadsheet Editor SDK

Spreadsheet Editor updates focus on collaboration, AI automation, and spreadsheet productivity.

• The Web Spreadsheet Editor adds real-time collaboration, including synchronized changes, live presence, editing indicators, and conflict handling. It also introduces rich-text cells and WebMCP-powered AI automation.
• The Blazor Spreadsheet Editor adds charts, data validation, Find and Replace, and additional customization events.
  

  

Desktop highlights

WinUI

WinUI adds multi-card Kanban drag-and-drop, configurable DataGrid and TreeGrid sorting, and usability improvements to Time Editors.

WinForms

• The WinForms Calculation Engine adds additional spreadsheet functions for analytics, statistics, aggregation, and multilingual scenarios.
• AI AssistView adds a customizable input toolbar, quick actions, and file attachments.

WPF

• Smart DataGrid adds AI-powered export, enabling users to create Excel or PDF exports using natural-language prompts.
  

  

• WPF DataGrid and Kanban also receive usability enhancements for editing, filtering, sorting, and multi-card interactions.

Which volume 3 updates should you explore?

With updates spanning several platforms and SDKs, start with the capabilities most relevant to what you’re building.

Explore Essential Studio 2026 Volume 3

Essential Studio 2026 Volume 3 expands what’s possible across AI, document workflows, dynamic forms, collaboration, and cross-platform UI development.

Whether you’re preparing enterprise content for RAG, generating Office documents with JavaScript, building adaptive interfaces, or adding collaborative document experiences, explore the features that fit your next project.

Ready to see what’s new?

Explore the complete What’s New and Release Notes documentation to find the features relevant to your project.

Have questions or feedback? Connect with us through the Syncfusion support and feedback channels.