---

Generate briefing documents, presentations, and Excel files from a single prompt with Copilot Cowork, pulling from your emails, calendar, and SharePoint through Work IQ — and fold in new tasks mid-run without stopping. Using Copilot Cowork, you can use the same platform that powers Claude Cowork. It’s designed for long-running, multi-step task automation. 

Use Critique in Researcher to pair a generation model with a dedicated review model, applying source reliability and evidence grounding before the report lands. Run model Council to submit one prompt to GPT and Claude simultaneously and compare their full reasoning side-by-side. 

These experiences with Copilot Cowork and Researcher are available now if your organization has the Frontier Program enabled. Jeremy Chapman, Microsoft 365 Director, shares how to choose, direct, and compare the right AI model for every task, all from within Microsoft 365.

One prompt. Three files. 

Copilot Cowork generates your briefing doc, presentation, and Excel output — grounded in Work IQ data and saved directly to OneDrive. Try it now.

Copilot Cowork handles new requests mid-run. 

Add meeting scheduling or an email update partway through and it integrates them into the active plan. Check it out.

No more copy/paste into unmanaged AI sites. 

Work IQ automatically supplies Cowork and Researcher with your emails, calendar, Teams transcripts, and SharePoint files. Every output is grounded in your actual data. See how it works.

QUICK LINKS: 

00:00 — Copilot capabilities 

01:06 — Copilot Cowork 

02:32 — Mid-Run Task Injection 

03:05 — Output 

04:17 — Researcher Critique: Dual-Model Pipeline 

05:58 — Work IQ Auto-Retrieval 

06:58 — Model Council 

08:50 — Wrap up

Link References

Try it at https://microsoft365.com/copilot

Unfamiliar with Microsoft Mechanics? 

As Microsoft’s official video series for IT, you can watch and share valuable content and demos of current and upcoming tech from the people who build it at Microsoft. 

• Subscribe to our YouTube: https://www.youtube.com/c/MicrosoftMechanicsSeries
• Talk with other IT Pros, join us on the Microsoft Tech Community: https://techcommunity.microsoft.com/t5/microsoft-mechanics-blog/bg-p/MicrosoftMechanicsBlog
• Watch or listen from anywhere, subscribe to our podcast: https://microsoftmechanics.libsyn.com/podcast

Keep getting this insider knowledge, join us on social: 

• Follow us on Twitter: https://twitter.com/MSFTMechanics 
• Share knowledge on LinkedIn: https://www.linkedin.com/company/microsoft-mechanics/
• Enjoy us on Instagram: https://www.instagram.com/msftmechanics/
• Loosen up with us on TikTok: https://www.tiktok.com/@msftmechanics 

---

Video Transcript:

-Now you don’t need to switch between AI model providers for the best models for work. Copilot has options from Anthropic and OpenAI available directly from Microsoft 365. Using Copilot Cowork, you can use the same platform that powers Claude Cowork. It’s designed for long-running, multi-step task automation and it’s grounded by Work IQ, so you don’t need to move files and data outside of Microsoft 365 to other potentially unprotected services. Researcher has also been expanded with multi-model intelligence, where the new Critique capability separates the models, with one used to generate and another to refine its research outputs. And the new Council capability lets you submit a single prompt and view a side-by-side comparison across multiple model outputs. 

-Now, these experiences with Copilot Cowork and Researcher are available now if your organization has the Frontier program enabled, and today I’ll go hands-on with each while explaining the mechanics of how they work. Let’s start with Copilot Cowork. So in this example, I need to prepare for a customer meeting, and I want Cowork to build me a briefing document in Word, a PowerPoint presentation, and an Excel file with customer insights. I already have Copilot pinned with my agents and it’s opened. 

-Before I start, I’ll show you what’s set up in the knowledge sources. I can access information on the web, from people, and from Work IQ, so it doesn’t rely on connectors to access my work files, calendar, or previous meetings. Now I’ll paste in my prompt with links to reference files so it can help me then prepare for my meeting, and I want Copilot to pull in details from relevant emails and my calendar. I’ve also referenced an existing briefing document template as an example to follow, as well as an Excel overview with customer-specific metrics and visuals. And I want it to create a new briefing document as well as a client-ready PowerPoint presentation with our differentiators and recommended next steps. 

-So now I’m going to kick off the process and Cowork will show its progress, its inputs and outputs on the upper right-hand side of the screen. Cowork will then reason through all of the inputs and tasks from my prompt, then systematically work through everything until it generates the files that I requested. And it’s not only using the files referenced, but also searching across my Work IQ information. As it works, I can even request more tasks while it’s running. 

-For example, I can ask it to schedule prep time with people on my team and send an email status update to the account team. Cowork just folds that into the plan and keeps going. It checks schedules, and here’s the meeting it proposes for me and Riley on my team to review, and I’ll create that right from here. Then it authors an email to Ellis from the account team that I can choose to edit manually if I want. I’ll go ahead and add a thank you in line and then hit send. This can process for several minutes, so to save a little time, I’ll move on to when everything is complete. You’ll see that on the right in the output folder, it’s created a Zava client presentation, a customer briefing doc, and also a customer overview Excel file. 

-Now, I’ll open up the briefing document first, and it has everything relevant to the meeting and it uses our standard briefing template. In fact, if I open up the original one, you can see just how close the formatting is. Now I’ll open the presentation it generated. It explains our work at a glance, with key metrics from Work IQ and referenced files, as well as revenue and growth highlights. Now if I move on to the generated Excel file and open that, it’s laid out our year-over-year performance and used it to create forecasts for this year. We can also see the growth trends over time, and if I click into Sales by Category, we can even see a detailed breakdown across different product lines with comparisons for the last two years. And as it worked on my behalf, everything was saved directly into OneDrive, so it’s protected and can be shared with my team like any other Microsoft 365 file. 

-Next, one of the most powerful experiences in Copilot, Researcher, has also added new multi-model intelligence capabilities in addition to its options for using Claude from Anthropic or GPT from OpenAI. Researcher now takes us a step further with Critique by using a combination of models to separate generation from evaluation tasks, where one model leads the generation phase, planning the task, iterating through retrieval steps, and producing an initial draft, while the second model then focuses on review and refinement, acting like an expert reviewer before the final report is presented to you. This is now the default experience, and having these models work together helps ensure higher-quality outputs. Let me show you. 

-From Copilot and Microsoft 365, I already have Researcher open. At the top right, I’ll expand the model picker and explain the options. Choosing Auto will automatically generate responses using Critique with the two models working together. Under that is an option for Model Council that I’ll walk through in a moment. Then there are also options to choose GPT and Claude as standalone models. So I’m going to keep Auto in this case, and then I’ll paste in my prompt to generate an executive brief about the competition in our industry and where there might be expansion opportunities. Now, this is a very research-intensive request that will need to retrieve, evaluate, and analyze many resources via Work IQ and the web. 

-Now I’ll submit my prompt to get it started. Researcher can take several minutes to research and reason over a topic and generate its response, so to save a little time, I’ll move to its output. On the top I can see the content was generated by GPT and refined by Claude. First, there’s an executive summary about the market-related conditions. As I scroll down, you can see it’s assessed source reliability, where it focuses on reputable, authoritative, and domain-appropriate sources. Then as I continue scrolling, it’s also assessed report completeness, where the reviewer model ensures that the final report satisfies the request, along with relevant insights. 

-As you can see with the rest of the citations, it’s enforced strict evidence grounding, making sure that every key claim is anchored to a reliable source. So for example, here you can see that it’s pulled in structured data from an Excel file with detailed financials and several relevant Word documents from our internal SharePoint sites. And it’s done all of this research automatically without me having to manually reference or upload files into my prompt. Both models work together in this case to improve the generated output. Next, let’s move on to Model Council in Researcher. Now, this lets you compare responses from different models side by side so that you can see where they agree, where they don’t, as well as what differentiates each model. 

-So I’m back in Researcher, and this time from the model picker, I’ll choose Model Council. From there, I’ll just paste in my detailed prompt, in this case to review our latest customer feedback interviews to find the top themes and give recommendations based on our current plans in motion. Again, this is going to leverage Work IQ to find and analyze recent Teams meeting transcripts, our product plans from files and SharePoint and more as research sources, and it’s a lot to process. Everything looks good here, so I’ll go ahead and send it. And in this case, Researcher asks clarifying questions to better understand my goal. 

-So I’ll choose a short one-to-five-page report length. Then below that I’ll type “Go ahead” and it gets to work. I only need to submit my prompt one time for both models to process it simultaneously. Again, this process can run 10 or more minutes, so I’ll skip to the output. You can see that each model has its own tile on top, and you can click into any of them to view their outputs. Below that is a summary for how each model did, comparing their responses. And I can also view a full output for each model. So I’m going to drill into the GPT output, and that shows me a split-screen view with the GPT tab open on the right, and I can scroll its results and I can look at its structured reasoning and its response and all the details. 

-Now moving to the Claude tab, I can also look at its detailed response and reasoning and everything that it performed to derive the output. I don’t need to run separate prompts to find the model that I prefer. Now Model Council helps do that work for me. So now Copilot and Microsoft 365 gives you direct access to leading models, including Anthropic and OpenAI, with multi-model intelligence and without having to switch between platforms. 

-To get started, enable the Frontier program in your Microsoft 365 environment. Then go to microsoft365.com/copilot or use the mobile app to try it out. And keep watching Microsoft Mechanics for the latest tech updates, and thanks so much for watching.

 

Stop guessing at prompts. Use research-ready templates that guide Microsoft Copilot toward clearer reasoning, better drafts, and transparent methods—so your work is faster, sharper, and credible.

Darcy Ogden, Ph. D., leads the academic researcher programs for Microsoft Global Skilling. A computational scientist and former professor of geophysics, Dr. Ogden has a passion for teaching and using new technology to accelerate research.

 

Guidance on using generative AI in research often lands at the extremes; it’s either overly optimistic or far too cautious. Most researchers, students, and professionals working with data or analysis know that the reality sits somewhere in between: all models are useful but fallible tools.

As researchers, we ask: What was this model designed to do? Where does it perform well? Where does it fall short? What assumptions are we making when we use this model?

Those same questions apply to generative AI. Understanding how these systems work and how they shape the outputs you receive can help you decide when to rely on them and when to adjust.

We’re all trying to figure out how best to work with generative AI, and there’s no simple, universal answer. But, in many cases, the work of research itself creates opportunities to apply generative AI thoughtfully and effectively.

Explore our new guide for researchers

As part of the latest Microsoft efforts to support graduate students, postdocs, and faculty aiming to use generative AI for research, we’re happy to share a new learning resource, The Academic Researcher's Guide to Generative AI. In this guide, we bring together recent insights and practical frameworks for considering generative AI as a research instrument. The guide’s purpose is to support researchers in asking well‑formed questions about the tools they use and in reflecting on the role that those tools play in research processes.

 

 

Bring generative AI into your research methodology

This new guide provides research-aligned approaches to prompting in Microsoft 365 Copilot Chat, along with frameworks for prompt development, testing, and documentation. Further, it includes ready-to-adapt prompting use cases for research scenarios. The following brief examples reflect the kinds of tasks that these prompts support:

• Research synthesis. Summarize the key arguments across these sources and note where the evidence conflicts.
• Writing support. Rewrite this paragraph for clarity and precision while keeping the original meaning.
• Data analysis. Explain the assumptions behind this statistical method and list situations where it may fail.

We’ve also included guidance on crafting quality prompts in Copilot, with techniques that can help reduce ambiguity and surface the reasoning behind responses. These approaches for prompting can deliver tailored, well-structured outputs suited for research purposes. The following examples highlight the types of instructions that researchers can use to make the most of Copilot prompts:

• Surface assumptions. State assumptions and show reasoning before providing the final answer.
• Limit sources. Use only the attached sources and flag any gaps or uncertainties in the evidence.
• Structure responses. Follow this structure: Context → key points → limitations → questions to be considered next.

This guide treats the use of generative AI like other models or tools you use in your research. Like them, generative AI has no native understanding of fields of study, datasets, or research constraints. The guide introduces an approach to using generative AI as a visible, documentable part of academic research. It treats interactions with Copilot as part of your methodology: something to record, review, and refine as you move through your research.

Put the guide to work

As generative AI becomes more common across academic and professional environments, the question is no longer whether to use it but how to use it well. As the models grow more capable, the challenge is how to use them in ways that support learning, integrity, and transparency. We developed this guide to help researchers and students engage these tools in ways that strengthen, rather than diminish learning and scholarly judgment.

We invite you to read The Academic Researcher's Guide to Generative AI. Use it as a starting point, adapt the frameworks to your own discipline and workflow, and contribute feedback about the guide so that we can continue to evolve this resource alongside the field itself.

 

 

A couple of months ago, we published a three-part series showing how to build multi-agent AI systems on Azure App Service using preview packages from the Microsoft Agent Framework (MAF) (formerly AutoGen / Semantic Kernel Agents). The series walked through async processing, the request-reply pattern, and client-side multi-agent orchestration — all running on App Service.

Since then, Microsoft Agent Framework has reached 1.0 GA — unifying AutoGen and Semantic Kernel into a single, production-ready agent platform. This post is a fresh start with the GA bits. We'll rebuild our travel-planner sample on the stable API surface, call out the breaking changes from preview, and get you up and running fast.

All of the code is in the companion repo: seligj95/app-service-multi-agent-maf-otel.

What Changed in MAF 1.0 GA

The 1.0 release is more than a version bump. Here's what moved:

• Unified platform. AutoGen and Semantic Kernel agent capabilities have converged into Microsoft.Agents.AI. One package, one API surface.
• Stable APIs with long-term support. The 1.0 contract is now locked for servicing. No more preview churn.
• Breaking change — Instructions on options removed. In preview, you set instructions through ChatClientAgentOptions.Instructions. In GA, pass them directly to the ChatClientAgent constructor.
• Breaking change — RunAsync parameter rename. The thread parameter is now session (type AgentSession). If you were using named arguments, this is a compile error.
• Microsoft.Extensions.AI upgraded. The framework moved from the 9.x preview of Microsoft.Extensions.AI to the stable 10.4.1 release.
• OpenTelemetry integration built in. The builder pipeline now includes UseOpenTelemetry() out of the box — more on that in Blog 2.

Our project references reflect the GA stack:

<PackageReference Include="Microsoft.Agents.AI" Version="1.0.0" />
<PackageReference Include="Microsoft.Extensions.AI" Version="10.4.1" />
<PackageReference Include="Azure.AI.OpenAI" Version="2.1.0" />

Why Azure App Service for AI Agents?

If you're building with Microsoft Agent Framework, you need somewhere to run your agents. You could reach for Kubernetes, containers, or serverless — but for most agent workloads, Azure App Service is the sweet spot. Here's why:

• No infrastructure management — App Service is fully managed. No clusters to configure, no container orchestration to learn. Deploy your .NET or Python agent code and it just runs.
• Always On — Agent workflows can take minutes. App Service's Always On feature (on Premium tiers) ensures your background workers never go cold, so agents are ready to process requests instantly.
• WebJobs for background processing — Long-running agent workflows don't belong in HTTP request handlers. App Service's built-in WebJob support gives you a dedicated background worker that shares the same deployment, configuration, and managed identity — no separate compute resource needed.
• Managed Identity everywhere — Zero secrets in your code. App Service's system-assigned managed identity authenticates to Azure OpenAI, Service Bus, Cosmos DB, and Application Insights automatically. No connection strings, no API keys, no rotation headaches.
• Built-in observability — Native integration with Application Insights and OpenTelemetry means you can see exactly what your agents are doing in production (more on this in Part 2).
• Enterprise-ready — VNet integration, deployment slots for safe rollouts, custom domains, auto-scaling rules, and built-in authentication. All the things you'll need when your agent POC becomes a production service.
• Cost-effective — A single P0v4 instance (~$75/month) hosts both your API and WebJob worker. Compare that to running separate container apps or a Kubernetes cluster for the same workload.

The bottom line: App Service lets you focus on building your agents, not managing infrastructure. And since MAF supports both .NET and Python — both first-class citizens on App Service — you're covered regardless of your language preference.

Architecture Overview

The sample is a travel planner that coordinates six specialized agents to build a personalized trip itinerary. Users fill out a form (destination, dates, budget, interests), and the system returns a comprehensive travel plan complete with weather forecasts, currency advice, a day-by-day itinerary, and a budget breakdown.

The Six Agents

1. Currency Converter — calls the Frankfurter API for real-time exchange rates
2. Weather Advisor — calls the National Weather Service API for forecasts and packing tips
3. Local Knowledge Expert — cultural insights, customs, and hidden gems
4. Itinerary Planner — day-by-day scheduling with timing and costs
5. Budget Optimizer — allocates spend across categories and suggests savings
6. Coordinator — assembles everything into a polished final plan

Four-Phase Workflow

Infrastructure

• Azure App Service (P0v4) — hosts the API and a continuous WebJob for background processing
• Azure Service Bus — decouples the API from heavy AI work (async request-reply)
• Azure Cosmos DB — stores task state, results, and per-agent chat histories (24-hour TTL)
• Azure OpenAI (GPT-4o) — powers all agent LLM calls
• Application Insights + Log Analytics — monitoring and diagnostics

ChatClientAgent Deep Dive

At the core of every agent is ChatClientAgent from Microsoft.Agents.AI. It wraps an IChatClient (from Microsoft.Extensions.AI) with instructions, a name, a description, and optionally a set of tools. This is client-side orchestration — you control the chat history, lifecycle, and execution order. No server-side Foundry agent resources are created.

Here's the BaseAgent pattern used by all six agents in the sample:

// BaseAgent.cs — constructor for agents with tools
Agent = new ChatClientAgent(
    chatClient,
    instructions: Instructions,
    name: AgentName,
    description: Description,
    tools: chatOptions.Tools?.ToList())
    .AsBuilder()
    .UseOpenTelemetry(sourceName: AgentName)
    .Build();

Notice the builder pipeline: .AsBuilder().UseOpenTelemetry(...).Build(). This opts every agent into the framework's built-in OpenTelemetry instrumentation with a single line. We'll explore what that telemetry looks like in Blog 2.

Invoking an agent is equally straightforward:

// BaseAgent.cs — InvokeAsync
public async Task<ChatMessage> InvokeAsync(
    IList<ChatMessage> chatHistory,
    CancellationToken cancellationToken = default)
{
    var response = await Agent.RunAsync(
        chatHistory, session: null, options: null, cancellationToken);

    return response.Messages.LastOrDefault()
        ?? new ChatMessage(ChatRole.Assistant, "No response generated.");
}

Key things to note:

• session: null — this is the renamed parameter (was thread in preview). We pass null because we manage chat history ourselves.
• The agent receives the full chatHistory list, so context accumulates across turns.
• Simple agents (Local Knowledge, Itinerary Planner, Budget Optimizer, Coordinator) use the tool-less constructor; agents that call external APIs (Currency, Weather) use the constructor that accepts ChatOptions with tools.

Tool Integration

Two of our agents — Weather Advisor and Currency Converter — call real external APIs through the MAF tool-calling pipeline. Tools are registered using AIFunctionFactory.Create() from Microsoft.Extensions.AI.

Here's how the WeatherAdvisorAgent wires up its tool:

// WeatherAdvisorAgent.cs
private static ChatOptions CreateChatOptions(
    IWeatherService weatherService, ILogger logger)
{
    var chatOptions = new ChatOptions
    {
        Tools = new List<AITool>
        {
            AIFunctionFactory.Create(
                GetWeatherForecastFunction(weatherService, logger))
        }
    };
    return chatOptions;
}

GetWeatherForecastFunction returns a Func<double, double, int, Task<string>> that the model can call with latitude, longitude, and number of days. Under the hood, it hits the National Weather Service API and returns a formatted forecast string. The Currency Converter follows the same pattern with the Frankfurter API.

This is one of the nicest parts of the GA API: you write a plain C# method, wrap it with AIFunctionFactory.Create(), and the framework handles the JSON schema generation, function-call parsing, and response routing automatically.

Multi-Phase Workflow Orchestration

The TravelPlanningWorkflow class coordinates all six agents. The key insight is that the orchestration is just C# code — no YAML, no graph DSL, no special runtime. You decide when agents run, what context they receive, and how results flow between phases.

// Phase 1: Parallel Information Gathering
var gatheringTasks = new[]
{
    GatherCurrencyInfoAsync(request, state, progress, cancellationToken),
    GatherWeatherInfoAsync(request, state, progress, cancellationToken),
    GatherLocalKnowledgeAsync(request, state, progress, cancellationToken)
};
await Task.WhenAll(gatheringTasks);

After Phase 1 completes, results are stored in a WorkflowState object — a simple dictionary-backed container that holds per-agent chat histories and contextual data:

// WorkflowState.cs
public Dictionary<string, object> Context { get; set; } = new();
public Dictionary<string, List<ChatMessage>> AgentChatHistories { get; set; } = new();

Phases 2–4 run sequentially, each pulling context from the previous phase. For example, the Itinerary Planner receives weather and local knowledge gathered in Phase 1:

var localKnowledge = state.GetFromContext<string>("LocalKnowledge") ?? "";
var weatherAdvice = state.GetFromContext<string>("WeatherAdvice") ?? "";

var itineraryChatHistory = state.GetChatHistory("ItineraryPlanner");
itineraryChatHistory.Add(new ChatMessage(ChatRole.User,
    $"Create a detailed {days}-day itinerary for {request.Destination}..."
    + $"\n\nWEATHER INFORMATION:\n{weatherAdvice}"
    + $"\n\nLOCAL KNOWLEDGE & TIPS:\n{localKnowledge}"));

var itineraryResponse = await _itineraryAgent.InvokeAsync(
    itineraryChatHistory, cancellationToken);

This pattern — parallel fan-out followed by sequential context enrichment — is simple, testable, and easy to extend. Need a seventh agent? Add it to the appropriate phase and wire it into WorkflowState.

Async Request-Reply Pattern

A multi-agent workflow with six LLM calls (some with tool invocations) can easily run 30–60 seconds. That's well beyond typical HTTP timeout expectations and not a great user experience for a synchronous request. We use the Async Request-Reply pattern to handle this:

1. The API receives the travel plan request and immediately queues a message to Service Bus.
2. It stores an initial task record in Cosmos DB with status queued and returns a taskId to the client.
3. A continuous WebJob (running as a separate process on the same App Service plan) picks up the message, executes the full multi-agent workflow, and writes the result back to Cosmos DB.
4. The client polls the API for status updates until the task reaches completed.

This pattern keeps the API responsive, makes the heavy work retriable (Service Bus handles retries and dead-lettering), and lets the WebJob run independently — you can restart it without affecting the API. We covered this pattern in detail in the previous series, so we won't repeat the plumbing here.

Deploy with azd

The repo is wired up with the Azure Developer CLI for one-command provisioning and deployment:

git clone https://github.com/seligj95/app-service-multi-agent-maf-otel.git
cd app-service-multi-agent-maf-otel
azd auth login
azd up

azd up provisions the following resources via Bicep:

• Azure App Service (P0v4 Windows) with a continuous WebJob
• Azure Service Bus namespace and queue
• Azure Cosmos DB account, database, and containers
• Azure AI Services (Azure OpenAI with GPT-4o deployment)
• Application Insights and Log Analytics workspace
• Managed Identity with all necessary role assignments

After deployment completes, azd outputs the App Service URL. Open it in your browser, fill in the travel form, and watch six agents collaborate on your trip plan in real time.

What's Next

We now have a production-ready multi-agent app running on App Service with the GA Microsoft Agent Framework. But how do you actually observe what these agents are doing? When six agents are making LLM calls, invoking tools, and passing context between phases — you need visibility into every step.

In the next post, we'll dive deep into how we instrumented these agents with OpenTelemetry and the new Agents (Preview) view in Application Insights — giving you full visibility into agent runs, token usage, tool calls, and model performance. You already saw the .UseOpenTelemetry() call in the builder pipeline; Blog 2 shows what that telemetry looks like end to end and how to light up the new Agents experience in the Azure portal.

Stay tuned!

Resources

• Sample repo — app-service-multi-agent-maf-otel
• Microsoft Agent Framework 1.0 GA Announcement
• Microsoft Agent Framework Documentation
• Previous Series — Part 3: Client-Side Multi-Agent Orchestration on App Service
• Microsoft.Extensions.AI Documentation
• Azure App Service Documentation

Table of Contents

Abstract

Introducing Agentic AI: The Agent Volume Scan

Why This Matters

Why AI-Informed Operations

Core Components

Enhanced Natural Language Interface

AI-Powered Analysis and Templates

What are the Benefits?

Business Benefits

Economic Benefits

Technical Benefits

Real‑World Scenario

Learn more

 

Abstract

The Azure NetApp Files VS Code Extension v1.2.0 introduces a major leap toward agentic, AI‑informed cloud operations with the debut of the agentic scanning of the volumes. Moving beyond traditional assistive AI, this release enables intelligent infrastructure analysis that can detect configuration risks, recommend remediations, and execute approved changes under user governance. Complemented by an expanded natural language interface, developers can now manage, optimize, and troubleshoot Azure NetApp Files resources through conversational commands - from performance monitoring to cross‑region replication, backup orchestration, and ARM template generation. Version 1.2.0 establishes the foundation for a multi‑agent system built to reduce operational toil and accelerate a shift toward self-managing enterprise storage in the cloud. 

Co-authors:

• Prabu Arjunan, Product Manager, NetApp
• Sagar Gupta, Product Manager, NetApp
• Nitya Gupta, Director of Product, NetApp

We are excited to announce Azure NetApp Files VS Code Extension v1.2.0, marking a significant evolution in how we approach cloud storage management. This release moves beyond assistive AI toward AI-informed infrastructure operations powered by our new Agentic Framework.

Introducing Agentic AI: The Agent Volume Scan

This release introduces our first agentic framework—the agent volume scan—which doesn’t just alert you to problems, it actively generates recommended action plans and can execute approved changes with your governance.

Key capabilities include:

• Agentic scanning across all ANF volumes in your subscription to trigger comprehensive infrastructure health checks whenever needed.
• AI-powered risk detection for configuration gaps that could cause outages, including:
  • Capacity risks: Usage threshold violations and approaching quota limits.
  • Security vulnerabilities: Overly permissive export policies (0.0.0.0/0 exposure) and incorrect subnet restrictions (e.g., 10.0.0.0/24).
  • Performance optimization: Cool access enablement opportunities for infrequently accessed data.
• One-click execution of approved changes directly to your Azure infrastructure.

Why This Matters

This release establishes the foundation for a multi-agent system designed to eliminate operational toils and make enterprise storage self-managing. The Agentic Volume Scanner demonstrates the model, and future agents will handle capacity planning, cost optimization, compliance auditing, and cross-cloud orchestration.

Why AI-Informed Operations

The Agentic Volume Scanner uses AI to analyze your infrastructure state, detect risks, and generate actionable remediation plans. Scanning is AI-based and initiated through user input. Currently, a scan is triggered when the user clicks "yes" on a notification after they select or change a subscription while the agent is active. Additionally, users can perform on-demand scans using the prompt "scan volumes." The plan is to schedule one scan every two hours during business days. 

This is not code generation or chat assistance. It is actionable intelligence where agents detect issues, generate remediation plans, and execute approved infrastructure changes while you maintain complete control.

Core Components

• VS Code Extension (TypeScript): Developer-facing UI, commands, and agent interaction prompts
• Agentic Framework: Orchestrates scanning, analysis, recommends plan generation, and execution flow (with approval)
• Cloud APIs (REST): Reads infrastructure state and applies approved configuration changes
• GitHub Copilot Integration: Natural language understanding and context-aware recommendations
• Generated Templates: ARM/Bicep/Terraform/PowerShell templates generated automatically for deployment
• Authentication (IAM): Secure enterprise identity and access control

Enhanced Natural Language Interface

This release significantly expands natural language capabilities to make storage management conversational.

Enabling Azure NetApp Files Data Lifecycle Management Agent 

Landing Page after the Azure NetApp Files VS Code extension installation and subscription selection

AI-Powered Analysis and Templates

The extension introduces a natural language chat interface through the @anf participant in GitHub Copilot Chat, allowing developers to manage Azure NetApp Files storage directly from VS Code using plain English commands — without leaving their editor. This is the first step toward a fully conversational storage management experience, covering four key areas: storage analysis and template generation, volume operations, cross-region replication, and backup and recovery. 

For the full list of supported prompts, refer the documentation. 

 

Leveraging @anf agent to perform operations using the VS Code extension.
For e.g. PowerShell module creation for the given ANF architecture.

What are the Benefits?

Business Benefits

• Accelerated remediation: Identify risks and move from detection → plan → approved execution in minutes
• Reduced operational friction: Standardized recommendations and approvals streamline collaboration between Dev, Ops, and IT
• Developer-first workflow: Storage operations stay inside VS Code, keeping teams in flow

Economic Benefits

• Lower waste: Proactively prevent over-provisioning and optimize for infrequently accessed data (cool access opportunities)
• Higher efficiency at scale: Reduce repeated manual checks by detecting common risks consistently across subscriptions.
• On-demand control: Trigger scans and automation only when needed, keeping approvals and governance in place while avoiding continuous background operations.

Technical Benefits

• AI-informed risk detection: Identify capacity, security, and performance risks early
• Governed action: The agent recommends and executes only approved changes
• Template generation in preferred formats: ARM/Bicep/Terraform/PowerShell for standardized deployments

Real‑World Scenario

Meet Sarah, an engineer supporting a production application:

Classic way: She signs into the Azure portal and navigates through multiple blades to locate the volume. From there, she manually checks performance metrics, reviews export policies for potential security gaps, and inspects quota thresholds to assess capacity risks. Each insight requires switching between different screens, cross-verifying details, and documenting findings separately. This fragmented workflow often stretches beyond 20 minutes, leaving room for interruptions, inconsistent documentation, and potential misconfigurations.

New way with v1.2.0: Sarah simply triggers the Volume Scanner inside VS Code. Within seconds, the agent analyzes the volume, surfaces prioritized risks, and generates a clear remediation plan. With one approval, the recommended fix is executed automatically—no portal hopping, no context switching, and no manual verification.

Result: Significantly faster resolution, fewer outages caused by overlooked risks, and consistently applied configurations—all completed without ever leaving the editor.

Learn more

• Install: VS Code Marketplace – Azure NetApp Files Extension
• Learn: Quick Start Guide & Documentation
• Build: Azure NetApp Files Storage Templates
• PostgreSQL with Azure NetApp Files – Specialized ARM template for PostgreSQL deployments.
• Microsoft Tech Community – Learn how AI accelerates cloud-native development
• Azure NetApp Files VS Code Extension: https://github.com/NetApp/anf-vscode-extension
• Feedback: https://github.com/NetApp/anf-vscode-extension/issues