Azure Verified Modules (AVM) has moved into the Azure Deployments team, inside Microsoft’s Azure engineering organization. That is the headline, and it is a big one for us.

AVM started as a community-led project inside Microsoft, built and maintained largely by people who cared about it alongside their day jobs in various roles and teams across Microsoft. It is now owned by an engineering team, with dedicated engineers working on it every day; as well as those who helped make AVM what it is today.

I want to be clear about what that does and does not mean, because I know the questions this raises. AVM is still open source. The repositories, specifications, the contribution model and the way you consume modules from the public registries are all unchanged. What has changed is the level of investment behind it, and how sustainable we can make it.

In short: Microsoft has increased its investment in AVM. It has moved from a community-led project into Azure engineering, with dedicated engineering resources behind it. It stays open-source. On the back of that, we are updating the support statement and introducing a three-tier module ownership model at the start of 2027 (more on these below).

This blog post has a lot of content, please take the time to read it all but feel free to use the table of contents below to help you navigate it.

If AVM is new to you

AVM is the Microsoft standard for Infrastructure as Code (IaC) modules for Azure, in both Bicep and Terraform. Every module is built to the same published specification, passes the same continuous integration (CI) tests, and is published to the official public Bicep and Terraform registries. The idea is simple: you should not have to write the same Azure IaC code again, and you should be able to trust what you pick up.

There is a lot more detail at aka.ms/AVM. And if you would rather watch than read, Jared Holgate and I covered AVM in our recent Azure Infra Summit session: watch the recording on YouTube.

What the move lets us fix: our support statement

Today, the AVM support statement includes day-based targets for responses and fixes. We have not met them consistently, and that does not give you clear or reliable expectations.

We are removing those targets and aligning with the support model used by Azure CLI, Azure PowerShell, Bicep, AzAPI, and the AzureRM Terraform provider.

The move into Azure engineering is the important part. Dedicated engineers will maintain modules directly and improve the tooling, automation, and framework used by all module owners. That is a stronger commitment than any fixed target we cannot reliably meet.

It also lets us be clearer about who maintains each module. Right now, every AVM module is treated identically, and that is not sustainable. So, we are introducing module tiering.

Introducing module tiering

Right now, every AVM module is treated identically. That is not sustainable. A resource group module needs almost no attention. A storage account or virtual machine module needs constant work as the underlying service evolves.

So, today we are introducing two tiers (and thinking about a third) based on who owns and maintains a module:

One thing that will not change: the bar. Every module in every tier is built to the same AVM specification and passes the same CI checks. Tiering describes who is behind a module, not its quality.

Ownership also stays aligned across languages if in Tier 1. If we own a module in Tier 1, we own it in both Bicep and Terraform.

Why we are not publishing the module tiering list yet

We want to know our real maintenance capacity before we commit. We are spending the rest of 2026 reducing toil and clearing the backlog. This work will show how many modules we can maintain.

We would rather publish a list that we can sustain than change it soon after publication. Publishing a list will also focus attention on excluded modules. We want clear evidence before those discussions start.

For context, our draft puts about 50 resource modules in Tier 1, across Bicep and Terraform. Current telemetry suggests these modules represent about 85 percent of AVM module deployments.

Usage is one input. Critical services and other factors also matter. We will validate the draft before making a public commitment.

Distributed ownership is still the point

AVM has always run on decentralized ownership and moving into engineering does not change that. If anything, it should help. Being inside Azure engineering puts us much closer to the product teams who build the services, and getting more of those teams to own the modules for their own service has been a goal from day one.

That is already happening. With the recent transition of Azure Landing Zones (ALZ), the Azure Migrate team now maintain the ALZ modules and the subscription vending modules in AVM. Those sit in Tier 2, but they are maintained by a dedicated engineering team. Tier 2 is not a lesser tier, it is a broader one.

However, if they currently own a resource module that will be included in Tier 1, they are still welcome to be involved in its ownership alongside the AVM engineering team, but we would also encourage them to own a module outside of Tier 1 so we have an owner on as many modules as possible. But all of this will be dealt with when we implement the tiering structure in early 2027.

Tier 2 ownership remains open to Microsoft employees and teams. The AVM engineering team will support those owners through improved tooling, automation, and the AVM framework. We will confirm ownership changes when we implement module tiering in early 2027.

Come and meet the team (AVM Community Call)

Rather than list names on a page, we would rather you meet the people. Join our next AVM community call, where the new engineering team looking after AVM will introduce themselves and take your questions. If you want to know who is behind AVM now, or discuss anything in this post, this will be the place to do it, and we can’t wait to see you all there!

Next community call: Monday 26th October 2026 @ 16:00 UK | 12:00 EDT | 09:00 PDT | 21:30 IST | 03:00 AEDT

This call will be streamed to YouTube live so use the "Set reminder" / "Notify Me" options on YouTube and also put an entry in your calendar to remind you. This means it will automatically be recorded and published live once finished as well 👍

YouTube Live Link: aka.ms/AVM/CommunityCall 

GitHub Issue Link: AVM Community Call - October 2026 · Issue #3079 · Azure/Azure-Verified-Modules  - please add a comment for any topics or discussions you'd like covered

Everyone is welcome whether you contribute to AVM or just use it. We want to welcome you for an insight into our roadmap over the next 6 months as well as an open discussion with you all.

What happens next

• We update the published module support statement and remove the day-based response targets.
• The team keeps burning down issues and pull requests and keeps reducing the manual toil in our CI.
• We validate our maintenance run rate through the end of calendar year 2026.
• We publish the initial tier classifications once we can stand behind them.
• We revisit Tier 3, including the legal and intellectual property questions, in 2027.

AVM got here because customers, partners and contributors backed it and used it in anger. That has not changed, and neither has our need for your input. If you think we are getting this wrong, tell us in GitHub Discussions. Candidly, the feedback we get on this will shape how we land it.

And finally, thank you to everyone who built this

AVM exists because many people put real work into it, often alongside their day jobs. Matt White, Charlie Grabiaud, Mate Barabas, Pankaj Meshram, were some of AVM’s key founders and helped shape the project during its early days that are no longer involved in AVM day-to-day. Jared Holgate, Alexander Sehr, Erika Gressi, Kris Baranek, Sebastian Graf, Rene Hezser and Chris Sidebotham remain involved today helping develop and maintain the AVM framework and specifications with the engineering team.

Some contributors have moved to other roles, teams, or companies. Many continue through issues, pull requests, community calls, and module ownership and contributions. Every contribution helped AVM reach this point and continue to drive it forward today.

The move into Azure engineering adds dedicated investment. It does not replace the community that built and sustained AVM.

To every past and present contributor and module owner: thank you for your time, commitment, and belief in AVM.

Thanks,

Jack and the AVM team.

How This All Started

So here’s the story. I just got back from a trip and had a pile of footage sitting on my laptop. Being the lazy (sorry, efficient) person I am, I fired up OpenCode and asked GPT-6 Astra, running on Microsoft Foundry, to cut me a travelogue. Nothing fancy: under two minutes, nice lighting, clean transitions, no cringy effects, a quick QA before showing me, and the output in its own folder. Easy, right? Nope.

This is what I got instead:

“Image processing blocked due to content policy violation.” Seriously? It’s holiday footage! Nothing even remotely dodgy in there. This is a classic false positive from the default guardrails, and the good news is it’s totally fixable. Let me show you how.

My Setup

Quick context before we dive in: I’ve got two models deployed on Microsoft Foundry, gpt-6-astra and gpt-6-sol. Both were running on Microsoft’s out-of-the-box guardrail.

Step 1: Find the Guardrails Page

Head over to the Microsoft Foundry portal, click Build, then hit Guardrails in the left menu. You’ll see three guardrails that Microsoft gives you by default: Microsoft.Default, Microsoft.DefaultV2 and Microsoft.MAIDefault.

Microsoft.DefaultV2 is the one every new deployment gets, which is why it’s sitting on both of my models. Here’s the catch: you can’t edit or delete these Microsoft-managed defaults. So instead of tweaking them, we’re going to build our own guardrail and swap it in.

Step 2: Create Your Own Guardrail

Smash that "Create" button and you’ll land on the Create guardrail page. This is where all the knobs and switches live:

Every control has three bits: the risk type, the intervention point (does it check what you send in, what the model spits out, or both?) and the action. The magic trick for loosening things up is flipping the action from Block to Annotate. With Annotate, Foundry still scans the content and tags it in the API response, but it stops slamming the door on your request.

So What Does Each Setting Actually Do?

Before you go on a switching-off spree, it’s worth knowing what each of these does and what you’re giving up when you loosen it. Here’s the quick tour:

• Jailbreak: This one catches prompts trying to trick the model into ignoring its rules. On Block, those prompts get rejected outright. On Annotate, they go through with a flag. Turn it off completely and you’re trusting the model’s own training to keep it in line.
• Network (egress rules): Controls which outbound calls a hosted agent is allowed to make. As the portal points out, it only applies to hosted agents, so for plain model deployments like mine it doesn’t change a thing.
• Indirect prompt injections: Watches user input and tool responses (files, docs, web pages the model reads) for sneaky instructions someone has planted. Leave it on and your agents are protected when they read outside content; switch it off and a dodgy file could quietly hijack your model. For an agentic tool like OpenCode, which reads files and runs shell commands, I’d honestly keep this one on, even if it’s just on Annotate.
• Spotlighting (Preview): Tags external content inside the prompt so the model can tell your real instructions apart from random untrusted data. Think of it as an extra seatbelt against indirect attacks.
• Content harms (Hate, Sexual, Self-harm, Violence): Each of these has a severity slider that starts at Medium blocking, meaning anything rated medium or higher gets blocked. Slide it down to Lowest blocking and only the really nasty stuff gets stopped, which kills off most false positives like mine. The asterisk means these four are mandatory: you can turn the dial down, but you can’t switch them off.
• Blocklists: Want to ban specific words or phrases, like profanity or your competitor’s name? This is where you do it. It’s off by default.
• Protected material for code and text: Checks whether the model is about to spit out known copyrighted text (song lyrics, articles and so on) or code lifted from public repos. Block stops it; Annotate lets it through with a flag. Switch it off and you’re rolling the dice on your app reproducing someone else’s copyrighted work.

Step 3: Pick Your Models

Hit Next and Foundry asks which agents and models you want this guardrail on. Any model you’ve already deployed in your project shows up here. For me that’s gpt-6-astra and gpt-6-sol, so I ticked both.

Step 4: Name It and Pick a Streaming Mode

One more Next and you’re on the Review page. Give your guardrail a name (I went with NoGuardrails, because subtlety isn’t my thing) and pick a streaming mode. You’ve got two choices:

• Default: Foundry buffers the response and runs it through the guardrail before each chunk goes out. Nothing reaches the user until it’s been checked. Safest option, but you’ll feel a bit of lag when streaming.
• Asynchronous: Content streams back the moment it’s generated, with the filters running in the background. Much snappier, but flagged content might flash up briefly before the filter catches it, so your app has to clean up after the fact. Microsoft pitches this for low-latency stuff like internal dev tools, which is exactly my use case.

Give the summary a quick once-over, then click Create. Done!

Did It Work? Yep!

With my shiny new guardrail in place, I fired off the exact same request, this time to GPT-6 Sol. And boom: no more content policy error. The model went straight to work scanning my footage and putting the video together.

Wrapping Up

Look, Microsoft’s default guardrails are a solid starting point, but they can be a bit trigger-happy when you’re doing perfectly legit stuff like video editing, creative work or internal tooling. Since you can’t touch the defaults, the trick is to roll your own: flip Block to Annotate where it makes sense, drag those content harm sliders down, pick the streaming mode that fits your app, and assign it to your deployments. That’s it!

One friendly word of warning though: with great power comes great responsibility. Only loosen what you actually need, keep things like indirect prompt injection detection switched on for any agent that reads files or browses the web, and think twice before doing this on anything customer-facing. And if you want to go further than the portal lets you, like switching content filters off completely, you’ll need to apply to Microsoft for approval first. Happy building!

The way we work with AI is evolving quickly.

Microsoft recently introduced the new Microsoft Copilot experience, bringing together new ways to ask, delegate, build and automate work while giving organizations additional controls for managing AI usage and spend.

In our recent webinar, “New Microsoft Copilot App: Which Mode to Use, What It Costs, and Who Gets Access,” we took a closer look at what these changes mean for organizations and the people using Copilot every day.

Rather than trying to recreate the entire session here, this post highlights some of the major topics we covered. For the demonstrations, examples and deeper discussion, watch the accompanying webinar recording.

What we covered

The session focused on four major areas:

• The evolution of the Microsoft Copilot experience
• The roles of Home, Code and Autopilot
• Microsoft Copilot Managed Runtime and enterprise governance
• Usage-based AI and the emerging discipline of FinOps for AI

Together, these capabilities point toward a Copilot experience that extends beyond conversational assistance and toward increasingly sophisticated AI-enabled work.

A new Microsoft Copilot experience

Microsoft has announced three major capabilities for the new Copilot experience: Home, Code and Autopilot.

Home brings Chat and Cowork together as a starting point for work. Microsoft is also bringing Word, Excel and PowerPoint capabilities into the Copilot experience, making it possible to create and continue working with Office content without continually rebuilding context across applications.

There is an important distinction between Chat and Cowork.

Chat addresses the conversational interactions many people already associate with Copilot: asking questions, looking up information, creating drafts and staying informed.

Cowork is designed for work you delegate. Rather than simply responding to an individual prompt, Cowork can work through more complex tasks end-to-end and return results for you to review and iterate upon.

Microsoft has also said that the experience is moving toward a point where users won't necessarily need to decide which mode to choose. Users will describe what they want to accomplish and Copilot can route the work to the appropriate capability.

That reflects an important change in how we should think about AI at work. The conversation is expanding from “What can I ask Copilot?” toward “What work can I accomplish with Copilot?”

Code: turning ideas into working solutions

One of the capabilities we spent time discussing and demonstrating during the webinar was Code.

Code is designed to enable people to build solutions by describing what they want to create. Microsoft says the capability is powered by the same underlying technology as GitHub Copilot and is intended to make software creation accessible to both experienced developers and people who may not consider themselves traditional programmers.

During the webinar, we explored this concept through an application-building example based on a requirements document.

The point wasn't that application development suddenly requires no planning or technical discipline. It was to demonstrate how dramatically the starting point can change when AI can help translate business requirements into working software.

Watch the webinar recording to see the example and the resulting application.

Where does AI-generated code actually run?

Making application creation easier immediately raises another question:

How does an organization govern all of those applications?

Microsoft Copilot Managed Runtime is designed to address that challenge.

Microsoft describes Managed Runtime as an enterprise-grade platform for running code within the Microsoft 365 tenant boundary. It provides a common foundation incorporating Microsoft-operated cloud hosting, identity, governed data access and lifecycle management.

Managed Runtime already supports apps created through Copilot Cowork, Copilot Code and Microsoft Copilot Studio.

This creates an important separation between two ideas:

AI makes building easier. Enterprise controls still matter when that software runs.

Microsoft operates the platform, while organizations retain control over the boundaries within which applications operate.

Autopilot: AI that continues working

The webinar also explored Autopilot, which Microsoft describes as a persistent, proactive and personal agent that can continue working even when the user isn't actively interacting with it.

This represents another shift in the AI experience.

Chat is naturally interactive. You ask something and Copilot responds.

Agentic experiences introduce the idea of delegating work that can continue beyond that individual interaction. That opens new possibilities for ongoing research, monitoring, preparation and other work that benefits from persistence.

In the webinar, we discussed what this transition could mean for people who increasingly treat AI not simply as a place to ask questions, but as another resource available to help them get work done.

As AI becomes more capable, cost management matters too

More capable AI workloads can also require different approaches to licensing and consumption.

Microsoft uses Copilot Credits as a common currency for eligible services using usage-based billing. Microsoft describes this consumption model as complementary to fixed subscription licensing, especially as more advanced or multi-step workloads can vary considerably in the amount of work required to complete a task.

That leads directly to another major subject from our webinar: FinOps for AI.

As organizations expand their use of AI, several questions become increasingly important:

• What are we consuming?
• Which services and scenarios are driving that consumption?
• What value are those scenarios creating?
• Where should we invest or optimize next?

Control, measure and optimize

A useful way to think about FinOps for AI is through three activities:

Control

Organizations need mechanisms for governing access and spend.

Microsoft's Cost Management capabilities support controls around usage-based AI experiences, including spending policies, limits, alerts and billing methods.

Organizations can therefore begin establishing guardrails around how consumption-based AI services are introduced.

Measure

You can't optimize what you can't see.

Microsoft provides consumption information through its Copilot Cost Management capabilities, giving administrators visibility into Copilot Credit consumption across supported services.

This moves the AI cost conversation beyond simply purchasing technology and toward understanding how it is actually being consumed.

Optimize

Once organizations understand consumption, they can make more deliberate decisions about where AI is producing meaningful value and where different approaches may be appropriate.

That makes FinOps for AI more than a billing conversation. It becomes part of the broader process of deciding where and how an organization wants to scale AI.

A useful way to think about what comes next

Perhaps the biggest takeaway from the webinar is that Microsoft Copilot is expanding beyond a single conversational interaction model.

The emerging experience spans several ways of working:

Ask when you need information or immediate assistance.

Delegate when you want AI to take on a more complex body of work.

Build when you want to turn an idea or requirement into a solution.

Automate when work should continue beyond the immediate conversation.

And surrounding those experiences are the governance and cost-management capabilities organizations need as AI adoption grows.

Watch the full webinar

We've only touched on the highlights here.

In the full webinar, we walk through the new Copilot experience, demonstrate application creation with Code, discuss Autopilot and Managed Runtime, and spend additional time looking at the emerging FinOps capabilities organizations can use to understand and govern AI consumption.

Watch the accompanying video for the complete discussion and demonstrations.

Learn more

Want to explore these announcements and capabilities in more detail?

Check out these official Microsoft resources:

• Introducing the new Copilot with Home, Code and Autopilot
• Microsoft Copilot Managed Runtime: Build where you want, run with confidence
• Usage-based billing and cost management for Copilot Credits
• Microsoft Copilot Credits licensing guidance
• Copilot Credits Guide

Over the last few months, I've spent a lot of time with customers and our teams on one of the biggest security shifts ahead of us: securing an enterprise where people and AI agents are both acting on behalf of the business.

It’s a challenge shaping Microsoft's approach to Secure AI. And while AI makes the challenge urgent, the underlying problem is broader. Organizations need to give more people, applications, workloads, and agents access to more resources, while maintaining control without adding more friction and complexity.

Identity and network access are at the center of the transition.

Customers are clear about what they need. Across my conversations with identity and network access leaders and practitioners, and through our ongoing customer research, four outcomes consistently rise to the top:

1. Keep my organization trusted and resilient
2. Give users and agents secure access without friction
3. Reduce the cost and complexity of access management
4. Adopt AI safely at enterprise scale

So, we're making a change to this blog.

Starting this month, we’re organizing “What’s New” around the outcomes you're trying to achieve, rather than around our product architecture. Our goal is to make the connection between what we're shipping, the challenges you’re having, and where we're headed much clearer. I welcome your feedback on this new approach in the comments.

What I'd pay attention to this month

We’re acting on your feedback with new capabilities that:

• Continue to make access more adaptive. Universal Continuous Access Evaluation in Global Secure Access can now use additional user-risk and device-revocation signals, including when a device is deleted, disabled, or becomes noncompliant.
• Strengthen how workloads establish trust. Service-to-service token binding uses mutual TLS proof of possession to cryptographically bind an access token to the workload that originated it.
• Take complexity out of everyday identity operations. From a guided path to Cloud Sync to Microsoft-managed certificates for TLS inspection, several of this month's updates are about making stronger security easier to deploy and operate.

Here's everything new in Microsoft Entra since September.

Outcome: Keep my organization trusted and resilient

Device signals added to Continuous Access Evaluation (CAE) in Global Secure Access  

Give hybrid users fast, seamless, and secure access with Universal Continuous Access Evaluation (CAE) in Global Secure Access. Universal CAE adapts access based on a user’s location, optimizing the experience on the corporate network while maintaining strong security controls. It now supports user-risk and device-revocation signals, including when a device is deleted, disabled, or becomes noncompliant.

Public Preview

Service-to-service token binding enabled for Entra tokens

This capability uses mutual TLS proof of possession (mTLS PoP) to cryptographically bind an access token to the originating workload. The initial release supports managed identity workloads running on Trusted Launch or Confidential VM/VM Scale Sets, using the latest compatible .NET libraries to access Azure Key Vault. Organizations can enable it in a controlled manner, validate it in preproduction, and expand by cohort.

General Availability

Outcome: Give users and agents secure access without friction

Improved device registration user experience for Windows

When users access resources through supported native applications protected by Microsoft Entra Conditional Access policies that require token protection, they may need to register their device before access is granted. The improved experience lets users complete registration directly during sign-in—without navigating a separate workflow.

General Availability

Streamline access request workflows for users in ServiceNow 

Users can request access packages and view their request history directly in ServiceNow. Designated approvers can review and approve or deny requests without leaving ServiceNow. Access packages, policies, and approver assignments remain centrally managed in Microsoft Entra ID Entitlement Management, combining a streamlined user experience with consistent governance.

General Availability

Enable B2B guest access with Global Secure Access

Guest users can connect through Global Secure Access while signed in to their home organization’s Microsoft Entra ID account. The client detects partner tenants where the user is a guest and offers an option to switch to the customer tenant context. Private traffic is then routed through the customer’s Global Secure Access service for secure, streamlined access.

Public Preview

Outcome: Reduce the cost and complexity of access management

Simplify migration from Microsoft Entra Connect Sync to Microsoft Entra Cloud Sync

The guided migration tool gives eligible organizations a structured path from Microsoft Entra Connect Sync to Microsoft Entra Cloud Sync. It brings key activities into one workflow: assessing readiness, setting up the provisioning agent and Cloud Sync configuration, activating Cloud Sync through a controlled transition, and validating the environment after activation.

General Availability

Move SAP SuccessFactors Provisioning to Workload Identity-based authentication 

Microsoft Entra now supports Workload Identity-based authentication for SAP SuccessFactors provisioning, replacing long-lived usernames and passwords with Entra-managed credentials and short-lived, standards-based access tokens. Customers can upgrade authentication in place on existing provisioning jobs, without recreating or restarting them. This helps organizations move to a more secure model ahead of SAP SuccessFactors’ planned deprecation of basic authentication for its APIs in November 2026. The option supports inbound provisioning to Active Directory and Microsoft Entra ID, as well as writeback scenarios, while reducing manual credential handling and rotation.

Public Preview

Clear null or empty attribute values within Microsoft Entra provisioning 

Microsoft Entra provisioning can now clear an existing target attribute when the corresponding source attribute is null or empty. Also known as null-value provisioning, this capability keeps target systems synchronized when values are removed from the system of record. It is available for API-driven inbound provisioning, Workday inbound user provisioning, and SAP SuccessFactors inbound user provisioning to Microsoft Entra ID and on-premises Active Directory.

Public Preview

Generate unique aliases with custom call-outs

Use custom call-outs with Azure Logic Apps during user provisioning to perform advanced attribute transformations for your organization. For example, custom call-outs can generate unique employee aliases. They are supported for create events in HR inbound, SaaS outbound, and cross-tenant synchronization provisioning flows in Microsoft Entra.

Public Preview

Discover and govern application groups and memberships

Microsoft Entra ID Governance can now discover groups and group memberships in connected applications. Administrators can identify local or orphaned groups without a matching Microsoft Entra object, as well as groups and users without a corresponding application assignment in Microsoft Entra ID. This helps organizations reconcile access, investigate potentially unauthorized access, and identify groups that should be governed through Microsoft Entra ID Governance.

Public Preview

Gain efficiency with Microsoft-managed certificates for TLS inspection in Global Secure Access 

Previously, TLS inspection required customers to provision and manage their own certificates and trust chains. With Microsoft-managed certificates, Microsoft provisions the inspection certificate, removing the need for customers to operate their own certificate authority or public key infrastructure to use TLS inspection.

Public Preview

Outcome: Adopt AI safely at enterprise scale

AI is changing the security problem.

For decades, much of identity and access has been built around understanding who is requesting access, what they should be allowed to do, and under what conditions. Now we need to answer those same questions for AI agents that can reason, act, use tools, access data, and operate on behalf of people and organizations.

That's why Secure AI is an area I'm personally spending a lot of time on across Microsoft.

I believe the answer has to start with visibility and control. Organizations need to know what agents exist, understand what they can access and do, contain them within appropriate boundaries, and continuously adapt those protections as the agent, its context, and its risk change.

Identity and network access are foundational to that system, but they're not sufficient on their own. Securing AI will require us to connect identity, access, network, endpoint, data, application, and runtime signals with the ability to act when risk changes.

At Microsoft Ignite, November 17–20, we'll share much more about how we're approaching this across Microsoft, including the role Microsoft Entra and Agent 365 will play.

This is one of the areas I'm most excited about, and one you'll hear much more about from me.

Onwards,

Yina Arenas

CVP and Chief Product Officer of Identity and Network Access

Follow me on LinkedIn

 Learn more about Microsoft Entra

Secure access for people and agents to AI, applications, and resources with comprehensive identity and network access solutions.

• ⁠Microsoft Entra News and Insights | Microsoft Security Blog
• Microsoft Entra blog | Tech Community
• Microsoft Entra documentation | Microsoft Learn
• Microsoft Entra discussions | Microsoft Community 

Excel has always been where work gets done.

The best outcomes in Excel rarely come from a single analysis. They come from bringing in the right data, preparing it with confidence, applying the processes you trust, and turning the result into something others can understand and act on.

Now, Copilot can help take on more of that work for you. From preparing the data and learning the repeatable processes behind your work to transforming the results into polished, connected experiences for your audience.

From data to something beautiful

With a simple prompt, Copilot can transform your workbook data into a polished, interactive canvas.

Whether you're creating executive reviews, project updates, status reports, or something entirely new, this helps turn workbook data into a dynamic experience tailored to your audience.

Since it stays connected to your workbook, it automatically updates as your data changes. If you want to modify the report, just ask Copilot. Refine the layout, surface a different insight, or tailor the story for your audience through conversation.

It’s a faster, more engaging way to share the insights in your data and help others act on them.

Teach Excel to work like you do

The final report is only part of the story. Behind every insight is a process. The approach you've refined through experience. The work that happens every week, month, and quarter before the final answer is ready.

You know that process best. Now, you can teach it to Copilot through conversation or demonstration.

Tell Copilot: With skill builder*, you can tell Copilot exactly what you want done. Share your preferred workflow, instructions, previous prompts, or examples of completed work, and Copilot can turn that knowledge into a reusable skill.

Show Copilot: Sometimes it's easier to demonstrate than explain. With skill recorder*, you can show Copilot how you complete a recurring task. As you perform the work, Copilot observes the process and turns those actions into a reusable skill.

Whether you show it or tell it, Copilot helps transform your expertise into a skill that can be used again and again. The next time that work comes around, Copilot is ready.

Less manual preparation, more progress

Great analysis starts with data you can trust.

Get the data you need: Skip the complexity of building Power Query queries yourself. With get data, this becomes a conversational experience. Simply describe the data you need, where to pull it from, and how it should be shaped, and let Copilot do the work.

Clean the data you have: Real-world data isn't always analysis-ready. Sometimes "USA," "US," and "United States" all appear in the same column. Sometimes data types are incorrect, formatting is inconsistent, or duplicate records slip through. With clean data, Copilot can identify potential issues, explain what it found, and recommend corrections before you begin your analysis.

Less time searching for data. Less time cleaning it up. More time putting it to work.

A more capable partner for your work

Together, these experiences help you spend less time on repetitive work and more time moving work forward.

Bring in data. Prepare it for analysis. Teach Copilot the processes you repeat. Create reports that stay connected to your latest information.

Because the future of Excel isn't just helping you analyze data. It's helping you spend less time doing the work and more time focused on the decisions.

Availability

• Interactive canvas is currently available in Insiders.
• Skill builder began rolling out to general availability this month.
• Skill recorder will be available in Insiders by the end of October.
• Get data will roll out to general availability mid-October. This can be accessed via the web app.
• Clean data began rolling out to general availability this month.

*This feature is subject to service capacity and usage limits, which may vary over time.