Microsoft Release Notes
Last updated: Mar 7, 2026
Microsoft Products (13)
All Microsoft Release Notes (372)
- March 2026
- No date parsed from source.
- First seen by Releasebot:Mar 7, 2026
Dynamics 365 Sales by Microsoft
Agentic CRM and ERP Solutions | Microsoft Dynamics 365
Microsoft Dynamics 365 enters a new era of AI powered business with agentic CRM and ERP apps that connect teams, processes and data to boost customer experiences and operational agility. Explore tours pricing and free trials for AI powered workflows.
MICROSOFT DYNAMICS 365
The new era of AI-powered business
Adapt and innovate with agentic CRM and ERP business applications.
See plans and pricing
Try for freeOVERVIEW
Transform how work gets done with AI agents
Connect teams, processes, and data across your entire organization to create exceptional customer experiences and operational agility.What is Dynamics 365?
Become more data-driven and innovative with agentic apps for sales, service, finance, and supply chain operations.
Explore Dynamics 365Take a guided tour
Get a closer look at how to improve specific business processes with Dynamics 365 apps.
Start your tourCompare plans and pricing
Find the right plan for your business needs by exploring the different options for each Dynamics 365 app.
See pricing overviewSOLUTIONS
One platform. Limitless possibilities
Modernize your CRM
Enhance customer relationships across sales, marketing, and service with an agentic CRM solution.
Explore agentic CRMAchieve more with agentic ERP
Improve sales efficiency
Personalize service experiences
PRODUCT DEMOS
Do more with agents in Dynamics 365
See how AI and agents work with Dynamics 365 applications to give every team an edge.Close more deals and deepen customer relationships with AI assistance.
APPS AND ADD-ONS
Customize Dynamics 365 with apps from Microsoft Marketplace
Better meet your specific business needs by adding industry-leading apps to Dynamics 365.Power BI
- Collaborate better with your data.
Copilot
- Your copilot for work
Adobe Acrobat for Microsoft Teams and Outlook
- Gain insights, edit, convert, and collaborate on PDFs
Cisco Call
- Harness the powerful, enterprise-grade Cisco Calling within Microsoft Teams
View all apps
CUSTOMER STORIES
How customers innovate with Dynamics 365
“With Dynamics 365, total cost of ownership went down by as much as 40 percent compared to our previous solution.”
Pepijn Brinkhoff, Lead Product Owner, ABN AMRO40%
Reduction in cost of ownershipFEATURED NEWS
What’s new and notable
Take your organization to the AI frontier
Join the free Microsoft AI Tour—learn, connect, and lead the future of innovation.
Learn moreImplement autonomous processes with agent-ready apps
Enhance AI agent collaboration with Model Context Protocol (MCP) servers for Dynamics 365.
Read the blogNEXT STEPS
Get started with Dynamics 365
Try for free
Get hands-on experience with Dynamics 365 business applications for 30 days.
Start a free trialChat with a Dynamics 365 expert
Available M-F 6 AM to 3 PM PT.
Chat nowRequest a call back
Have a Dynamics 365 expert contact you.
Send requestCall a Dynamics 365 expert
Available M-F 6 AM to 3 PM PT.
Original source Report a problem
Call
855 270 0615 - March 2026
- No date parsed from source.
- First seen by Releasebot:Mar 7, 2026
Dynamics 365 Sales by Microsoft
Release plans for Dynamics 365, Power Platform, Cloud for Industry, and Copilot - Dynamics 365 | Microsoft Learn
Microsoft outlines release plans across Dynamics 365 Power Platform Cloud for Industry and Copilot, highlighting upcoming features and scheduled releases from Oct 2024 through Mar 2026. A roadmap snapshot for phased capability rollouts rather than current changes.
Release plans for Dynamics 365, Power Platform, Cloud for Industry, and Copilot
Find out what's new in Dynamics 365, Power Platform, Cloud for Industry, and Copilot.
REFERENCE
- Release planner
REFERENCE
- Archived release plans
2025 release wave 2
Features releasing from October 2025 through March 2026.
Microsoft Dynamics 365
Microsoft Power Platform
Role-based Copilot offerings
2025 release wave 1
Features releasing from April 2025 through September 2025.
Microsoft Dynamics 365
Microsoft Power Platform
Role-based Copilot offerings
Microsoft Cloud for Industry
2024 release wave 2
Features releasing from October 2024 through March 2025.
Microsoft Dynamics 365
Microsoft Power Platform
Original source Report a problem All of your release notes in one feed
Join Releasebot and get updates from Microsoft and hundreds of other software products.
- Mar 6, 2026
- Date parsed from source:Mar 6, 2026
- First seen by Releasebot:Mar 7, 2026
Version 145.0.3800.97: March 6, 2026
Microsoft delivers bug fixes and security updates to improve stability and performance.
Release Summary
Fixes
Fixed various bugs and performance issues.
Security
Stable channel security updates are listed here. .
Original source Report a problem - Mar 6, 2026
- Date parsed from source:Mar 6, 2026
- First seen by Releasebot:Mar 7, 2026
Version 144.0.3719.162: March 6, 2026
Microsoft releases bug fixes and performance improvements plus security updates for the stable channel.
Release Summary
Fixes
Fixed various bugs and performance issues.
Security
Stable channel security updates are listed here.
Original source Report a problem - Mar 6, 2026
- Date parsed from source:Mar 6, 2026
- First seen by Releasebot:Mar 6, 2026
Announcing TypeScript 6.0 RC - TypeScript
Microsoft announces the Release Candidate of TypeScript 6.0, a bridge to the Go-based 7.0 future. The RC aligns with 7.0 goals and adds es2025 target, Temporal and upsert types, subpath imports, stableTypeOrdering, and DOM lib improvements, inviting users to try and provide feedback.
Release Candidate (RC) for TypeScript 6.0
Today we are excited to announce the Release Candidate (RC) of TypeScript 6.0! To get started using the RC, you can get it through npm with the following command:
- npm install -D typescript@rc
TypeScript 6.0 is a unique release in that we intend for it to be the last release based on the current JavaScript codebase. As announced last year (with recent updates here), we are working on a new codebase for the TypeScript compiler and language service written in Go that takes advantage of the speed of native code and shared-memory multi-threading. This new codebase will be the foundation of TypeScript 7.0 and beyond. TypeScript 6.0 will be the immediate precursor to that release, and in many ways it will act as the bridge between TypeScript 5.9 and 7.0. As such, most changes in TypeScript 6.0 are meant to help align and prepare for adopting TypeScript 7.0.
With that said, there are some new features and improvements that are not just about alignment. Let’s take a look at some of the highlights of this release, followed by a more detailed look at what’s changing for 7.0 and how to prepare for it.
What’s New Since the Beta?
Since TypeScript 6.0 beta, we have made a few noteworthy changes – mostly to align with the behavior of TypeScript 7.0.
One adjustment is in type-checking for function expressions in generic calls, especially those occurring in generic JSX expressions (see this pull request). This will typically catch more bugs in existing code, though you may find that some generic calls may need an explicit type argument.
We have also extended our deprecation of import assertion syntax (i.e. import ... assert {...}) to import() calls to import() calls like import(..., { assert: {...}})
Finally, we have updated the DOM types to reflect the latest web standards, including some adjustments to the Temporal APIs as well.
Less Context-Sensitivity on this-less Functions
When parameters don’t have explicit types written out, TypeScript can usually infer them based on an expected type, or even through other arguments in the same function call.
[code examples omitted]
Here, TypeScript can infer the type of y in the consume function based on the inferred T from the produce function, regardless of the order of the properties. But what about if these functions were written using method syntax instead of arrow function syntax?
[more examples omitted]
Strangely enough, the second call to callIt results in an error because TypeScript is not able to infer the type of y in the consume method. What’s happening here is that when TypeScript is trying to find candidates for T, it will first skip over functions whose parameters don’t have explicit types. It does this because certain functions may need the inferred type of T to be correctly checked – in our case, we need to know the type of T to analyze our consume function.
These functions are called contextually sensitive functions – basically, functions that have parameters without explicit types. Eventually the type system will need to figure out types for these parameters – but this is a bit at odds with how inference works in generic functions because the two "pull" on types in different directions.
[more code/examples omitted]
To solve this, TypeScript skips over contextually sensitive functions during type argument inference, and instead checks and infers from other arguments first. If skipping over contextually sensitive functions doesn’t work, inference just continues across any unchecked arguments, going left-to-right in the argument list. In the example immediately above, TypeScript will skip over the callback during inference for T, but will then look at the second argument, 42, and infer that T is number. Then, when it comes back to check the callback, it will have a contextual type of (x: number) => void, which allows it to infer that x is a number as well.
So what’s going on in our earlier examples?
[examples omitted]
In both examples, produce is assigned a function with an explicitly-typed x parameter. Shouldn’t they be checked identically?
The issue is subtle: most functions (like the ones using method syntax) have an implicit this parameter, but arrow functions do not. Any usage of this could require "pulling" on the type of T – for example, knowing the type of the containing object literal could in turn require the type of consume, which uses T.
But we’re not using this! Sure, the function might have a this value at runtime, but it’s never used!
TypeScript 6.0 takes this into account when it decides if a function is contextually sensitive or not. If this is never actually used in a function, then it is not considered contextually sensitive. That means these functions will be seen as higher-priority when it comes to type inference, and all of our examples above now work!
This change was provided thanks to the work of Mateusz Burzyński.
Subpath Imports Starting with #/
When Node.js added support for modules, it added a feature called "subpath imports". This is basically a field called imports which allows packages to create internal aliases for modules within their package.
[example package.json omitted]
This allows modules in my-package to import from #root instead of having to use a relative path like ../../index.js, and basically allows any other module to write something like import * as utils from "#root/utils.js";
[more examples omitted]
One minor annoyance with this feature has been that developers always had to write something after the # when specifying a subpath import. Here, we used root, but it is a bit useless since there is no directory we’re mapping over other than ./dist/
Developers who have used bundlers are also accustomed to using path-mapping to avoid long relative paths. A familiar convention with bundlers has been to use a simple @/ as the prefix. Unfortunately, subpath imports could not start with #/ at all, leading to a lot of confusion for developers trying to adopt them in their projects.
But more recently, Node.js added support for subpath imports starting with #/. This allows packages to use a simple #/ prefix for their subpath imports without needing to add an extra segment.
[example package.json omitted]
This is supported in newer Node.js 20 releases, and so TypeScript now supports it under the options node20, nodenext, and bundler for the --moduleResolution setting.
This work was done thanks to magic-akari, and the implementing pull request can be found here.
Combining --moduleResolution bundler with --module commonjs
TypeScript’s --moduleResolution bundler setting was previously only allowed to be used with --module esnext or --module preserve; however, with the deprecation of --moduleResolution node (a.k.a. --moduleResolution node10), this new combination is often the most suitable upgrade path for many projects.
Projects will often want to instead plan out a migration towards either
- --module preserve and --moduleResolution bundler
- --module nodenext
depending on your project type (e.g. bundled web app, Bun app, or Node.js app).
More information can be found at this implementing pull request.
The --stableTypeOrdering Flag
As part of our ongoing work on TypeScript’s native port, we’ve introduced a new flag called --stableTypeOrdering intended to assist with 6.0-to-7.0 migrations.
Today, TypeScript assigns type IDs (internal tracking numbers) to types in the order they are encountered, and uses these IDs to sort union types in a consistent manner. A similar process occurs for properties. As a result, the order in which things are declared in a program can have possibly surprising effects on things like declaration emit.
[code examples omitted]
One of the major architectural improvements in TypeScript 7 is parallel type checking, which dramatically improves overall check time. However, parallelism introduces a challenge: when different type-checkers visit nodes, types, and symbols in different orders, the internal IDs assigned to these constructs become non-deterministic. This in turn leads to confusing non-deterministic output, where two files with identical contents in the same program can produce different declaration files, or even calculate different errors when analyzing the same file. To fix this, TypeScript 7.0 sorts its internal objects (e.g. types and symbols) according to a deterministic algorithm based on the content of the object. This ensures that all checkers encounter the same object order regardless of how and when they were created. As a consequence, in the given example, TypeScript 7 will always print 100 | 500, removing the ordering instability entirely.
This means that TypeScript 6 and 7 can and do sometimes display different ordering. While these ordering changes are almost always benign, if you’re comparing compiler outputs between runs (for example, checking emitted declaration files in 6.0 vs 7.0), these different orderings can produce a lot of noise that makes it difficult to assess correctness. Occasionally though, you may witness a change in ordering that causes a type error to appear or disappear, which can be even more confusing.
To help with this situation, in 6.0, you can specify the new --stableTypeOrdering flag. This makes 6.0’s type ordering behavior match 7.0’s, reducing the number of differences between the two codebases. Note that we don’t necessarily encourage using this flag all the time as it can add a substantial slowdown to type-checking (up to 25% depending on codebase).
If you encounter a type error using --stableTypeOrdering, this is typically due to inference differences. The previous inference without --stableTypeOrdering happened to work based on the current ordering of types in your program. To help with this, you’ll often benefit from providing an explicit type somewhere. Often, this will be a type argument
- someFunctionCall(/.../);
- someFunctionCall(/.../);
or a variable annotation for an argument you intend to pass into a call.
[example omitted]
Note that this flag is only intended to help diagnose differences between 6.0 and 7.0 – it is not intended to be used as a long-term feature
See more at this pull-request.
es2025 option for target and lib
TypeScript 6.0 adds support for the es2025 option for both target and lib. While there are no new JavaScript language features in ES2025, this new target adds new types for built-in APIs (e.g. RegExp.escape), and moves a few declarations from esnext into es2025 (e.g. Promise.try, Iterator methods, and Set methods). Work to enable the new target was contributed thanks to Kenta Moriuchi.
New Types for Temporal
The long-awaited Temporal proposal has reached stage 3 and is expected to be added to JavaScript in the near future. TypeScript 6.0 now includes built-in types for the Temporal API, so you can start using it in your TypeScript code today via --target esnext or "lib": ["esnext"] (or the more-granular temporal.esnext).
[example code omitted]
Temporal is already usable in several runtimes, so you should be able to start experimenting with it soon. Documentation on the Temporal APIs is available on MDN, though it may still be incomplete.
This work was contributed thanks to GitHub user Renegade334.
New Types for "upsert" Methods (a.k.a. getOrInsert)
A common pattern with Maps is to check if a key exists, and if not, set and fetch a default value.
[example code omitted]
This pattern can be tedious. ECMAScript’s "upsert" proposal recently reached stage 4, and introduces 2 new methods on Map and WeakMap:
- getOrInsert
- getOrInsertComputed
These methods have been added to the esnext lib so that you can start using them immediately in TypeScript 6.0.
With getOrInsert, we can replace our code above with the following:
[example code omitted]
getOrInsertComputed works similarly, but is for cases where the default value may be expensive to compute (e.g. requires lots of computations, allocations, or does long-running synchronous I/O). Instead, it takes a callback that will only be called if the key is not already present.
[example omitted]
This callback is also given the key as an argument, which can be useful for cases where the default value is based on the key.
This update was contributed thanks to GitHub user Renegade334.
RegExp.escape
When constructing some literal string to match within a regular expression, it is important to escape special regular expression characters like *, +, ?, (, ), etc. The RegExp Escaping ECMAScript proposal has reached stage 4, and introduces a new RegExp.escape function that takes care of this for you.
[example code omitted]
RegExp.escape is available in the es2025 lib, so you can start using it in TypeScript 6.0 today.
This work was contributed thanks Kenta Moriuchi.
The dom lib Now Contains dom.iterable and dom.asynciterable
TypeScript’s lib option allows you to specify which global declarations your target runtime has. One option is dom to represent web environments (i.e. browsers, who implement the DOM APIs). Previously, the DOM APIs were partially split out into dom.iterable and dom.asynciterable for environments that didn’t support Iterables and AsyncIterables. This meant that you had to explicitly add dom.iterable to use iteration methods on DOM collections like NodeList or HTMLCollection.
In TypeScript 6.0, the contents of lib.dom.iterable.d.ts and lib.dom.asynciterable.d.ts are fully included in lib.dom.d.ts. You can still reference dom.iterable and dom.asynciterable in your configuration file’s "lib" array, but they are now just empty files.
[example code omitted]
This is a quality-of-life improvement that eliminates a common point of confusion, since no major modern browser lacks these capabilities. If you were already including both dom and dom.iterable, you can now simplify to just dom.
See more at this issue and its corresponding pull request.
Breaking Changes and Deprecations in TypeScript 6.0
TypeScript 6.0 arrives as a significant transition release, designed to prepare developers for TypeScript 7.0, the upcoming native port of the TypeScript compiler. While TypeScript 6.0 maintains full compatibility with your existing TypeScript knowledge and continues to be API compatible with TypeScript 5.9, this release introduces a number of breaking changes and deprecations that reflect the evolving JavaScript ecosystem and set the stage for TypeScript 7.0.
[long list of deprecations and changes omitted for brevity]
Preparing for TypeScript 7.0
TypeScript 6.0 is designed as a transition release. While options deprecated in TypeScript 6.0 will continue to work without errors when "ignoreDeprecations": "6.0" is set, those options will be removed entirely in TypeScript 7.0 (the native TypeScript port). If you’re seeing deprecation warnings after upgrading to TypeScript 6.0, we strongly recommend addressing them before adopting TypeScript 7.0 (or trying native previews) in your project.
As for the schedule, we expect TypeScript 7.0 to follow soon after TypeScript 6.0. This should help us maintain continuity while giving us a faster feedback loop for migration issues discovered during adoption.
What’s Next?
At this point, TypeScript 6.0 is feature-complete, and we anticipate very few changes apart from critical bug fixes to the compiler. Over the next few weeks, we’ll focus on addressing issues reported on the 6.0 branch, so we encourage you to try the RC and share feedback.
We also publish nightly builds on npm and in Visual Studio Code, which can provide a faster snapshot of recently fixed issues.
We are also continuing to work on TypeScript 7.0, and we publish nightly builds of our native previews along with a VS Code extension too. Feedback on both 6.0 and 7.0 are very much appreciated, and we encourage you to try out both if you can.
So give TypeScript 6.0 RC a try in your project, and let us know what you think!
Happy Hacking!
– Daniel Rosenwasser and the TypeScript Team
Original source Report a problem - Mar 4, 2026
- Date parsed from source:Mar 4, 2026
- First seen by Releasebot:Mar 5, 2026
- Modified by Releasebot:Mar 6, 2026
Visual Studio Code by Microsoft
February 2026 (version 1.110)
Microsoft releases February 2026 VS Code with extensive agent improvements, background agent controls, Claude integration and new agent plugins, plus debugging panels, session memory, context compaction, forked chats, and accessibility and UI upgrades.
February 2026 (version 1.110)
Release date: March 4, 2026
Downloads: Windows: x64
Arm64 | Mac: Universal
Intel
silicon | Linux: deb
rpm
tarball
Arm
snapWelcome to the February 2026 release of Visual Studio Code. This release makes agents practical for longer-running and more complex tasks, giving you more control and visibility, new ways to extend agents, and smarter session management.
• Agent plugins: install prepackaged bundles of skills, tools, and hooks from the Extensions view
• Agentic browser tools: let the agent drive the browser to interact with your app and verify its own changes
• Session memory: persist plans and guidance across conversation turns
• Context compaction: manually compact conversation history to free up context space
• Fork a chat session: create a new, independent session that inherits conversation history to explore alternative approaches
• Agent Debug panel: get real-time visibility into agent events, tool calls, and loaded customizations
• Chat accessibility: use chat to its fullest with screen reader improvements, keyboard navigation, and notification signals
• Create agent customizations from chat: generate prompts, skills, agents, and hooks directly from a conversation
• Kitty graphics protocol: render high-fidelity images directly in the integrated terminalHappy Coding!
If you'd like to read these release notes online, go to Updates on code.visualstudio.com.
Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.Agent controls
Whether you are debugging an agent's behavior, tweaking approval flows, or handing work off to a background process, these updates give you more visibility and control over how agents run.Background agents
With background agents, you can hand off tasks to Copilot CLI, while still keeping track of them in VS Code. We have made several improvements to align the capabilities and experience of background agents with local and cloud agents.• Context compaction: Copilot automatically compacts the conversation history when the context window reaches its limit. You can now also manually trigger compaction for background agents with the /compact slash command.
• Use /slash commands: chat customization options like prompt files, hooks, and skills are now also available in background agent sessions as slash commands.
• Rename background agent sessions: you can now rename your background agent sessions to keep track of them more easily.Claude agents
Last month, we added Claude agents, enabling you to interact with the Claude Agent SDK using Claude models included in your GitHub Copilot subscription.This month, we've expanded this experience with new features and improvements:
• Steering and queuing to let you send follow-up messages mid-conversation to alter the agent's approach or to queue up additional requests.
• Session renaming
• Context window rendering with compaction
• Additional slash commands
◦ /compact for on-demand compaction
◦ /agents to manage custom agents
◦ /hooks to manage Claude hooks
• Add the getDiagnostics tool to let the agent access editor and workspace problems
• Significant performance improvementsMore improvements are planned. Share your feedback on GitHub!
Agent Debug panel (Preview)
With different agent customizations like hooks, skills, and custom agents, it can sometimes be difficult to understand what happens when you send a message to an agent. The Agent Debug panel gives you deeper visibility into your chat sessions and how your chat customizations are loaded.The Agent Debug panel shows chat events in real time, including chat customization events, system prompts, tool calls, and more. You can see exactly which prompt files, skills, hooks, and other customizations are loaded for a session, making it easier to understand and troubleshoot your agent configuration. This replaces the old Diagnostics chat action with a richer, more detailed view.
Open the panel from the Command Palette with Developer: Open Agent Debug Panel, or select the gear icon at the top of the Chat view and choose View Agent Logs.
The panel also includes a chart view that displays a visual hierarchy of events, so you can quickly understand the structure and sequence of what happens during a chat session.
This experience is still in preview, so try it out and share your feedback!
Note: The Agent Debug panel is currently only available for local chat sessions. Log data is not persisted, so you can only view logs for chat sessions from your current VS Code session.
Slash commands for enabling auto approval
You can now toggle global auto approve directly from the chat input using slash commands, without navigating to settings:• /autoApprove enables global auto approve for all tools
• /disableAutoApprove disables global auto approve/yolo and /disableYolo are aliases for the same commands.
CAUTION: Global auto approve skips all tool confirmation prompts, letting the agent run tools and terminal commands without waiting for your approval. This can speed up longer, multi-step tasks but means you won't have the opportunity to cancel potentially destructive actions. Make sure you understand the security implications before enabling it and consider using terminal sandboxing for additional protection.
Edit and ask mode changes
Setting: chat.editMode.hiddenAs agents have evolved, agent mode now handles everything edit mode can do and more, with better performance and reliability. Edit mode is now hidden from the agent picker by default, so users benefit from the most capable mode without having to choose between options. You can bring it back by disabling the chat.editMode.hidden setting.
Ask mode is now backed by a custom agent definition, making it a fully agentic experience. This resolves previous limitations, such as requiring a new session when switching between ask and agent mode.
Both changes demonstrate how to customize your own agents. If you prefer edit mode or want your own version of ask mode, create a custom agent that matches your needs by defining its tools, prompt, and language model. When you disable chat.editMode.hidden, you can select the View edit agent action in the agent picker to view the agent declaration that powers edit mode, which can serve as a starting point for your own custom agent.
Learn how to create custom agents in the custom agents documentation.
Ask questions tool
The askQuestions tool, which presents a question carousel UI during chat interactions, has been moved into VS Code core. This improves reliability when canceling requests and enables the tool to work consistently across different contexts, including subagents.When the carousel is active, you can now send a steering message without needing to reply to or dismiss pending questions first. This allows you to redirect the agent's response on the fly, even in the middle of a question sequence. Use the keyboard to navigate between questions with unassigned (next) and unassigned (previous).
Prevent auto-suspend during chat
VS Code now asks the operating system not to automatically suspend the machine while a chat request is running. You can step away from your computer without worrying about interrupting the agent's response.Note that closing the lid of an unplugged laptop still triggers suspension.
Agent extensibility
Agents are only as useful as the tools and customizations you give them. This release makes it easier to extend what agents can do, from installable plugin bundles to browser automation and new code-aware tools.Agent plugins (Experimental)
Settings: chat.plugins.enabled, chat.plugins.marketplaces, chat.plugins.pathsVS Code now supports agent plugins, which are prepackaged bundles of chat customizations. Plugins can contain skills, commands, agents, MCP servers, and hooks.
You can search and install agent plugins directly from the Extensions view within VS Code. Enter @agentPlugins in the search box or run the Chat: Plugins command from the Command Palette.
By default, VS Code retrieves plugins from the copilot-plugins and awesome-copilot repos. You can configure more sources via the following settings:
• chat.plugins.marketplaces: add additional plugin marketplaces by specifying GitHub or plain git repositories. The setting can also support Claude-style marketplaces such as anthropics/claude-code.
• chat.plugins.paths: register local plugin directories by specifying their paths and enabling or disabling them.Learn more about agent plugins in the agent plugins documentation.
Agentic browser tools (Experimental)
Setting: workbench.browser.enableChatToolsIn the previous release, we added a new integrated browser in VS Code desktop which lets you interact with web pages directly within the editor. But what if your agent could autonomously use this browser and validate changes to your website while it's building it?
In this release, we added a set of tools for agents to read and interact with the integrated browser. As the agent interacts with the page, it sees updates to page content and any errors and warnings in the console. The tools work out of the box without the need to install any extra dependencies.
• Page navigation: openBrowserPage, navigatePage
• Page content and appearance: readPage, screenshotPage
• User interaction: clickElement, hoverElement, dragElement, typeInPage, handleDialog
• Custom browser automation: runPlaywrightCodeThese tools give agents the ability to perform simultaneous authoring and verification of web apps and close the development loop for agents.
By default, pages opened by the agent run in private, in-memory sessions. This gives you control over what browsing data the agent can access. To give the agent access to a specific web page in the integrated browser, you can explicitly share the page with the agent to give temporary access and any saved data.
To try out the new tools, enable workbench.browser.enableChatTools and enable the browser tools in the chat tools picker.
Get started with the browser agent testing guide for a step-by-step tutorial.
Create agent customizations from chat
You can now generate agent customization files directly from a chat conversation by using new /create-* slash commands in agent mode:• /create-prompt: generate a reusable prompt file
• /create-instruction: generate an instruction file for project conventions
• /create-skill: extract a multi-step workflow into a skill package
• /create-agent: create a specialized custom agent persona
• /create-hook: create a hook configuration for lifecycle automationEach command guides you through the creation process and lets you choose between user-level (account-wide) or workspace-level (project-specific) storage.
The commands can also extract patterns from an ongoing conversation. For example, after debugging an issue over several turns, use /create-skill to capture the procedure as a reusable skill, or /create-instruction to turn corrections into project conventions.
You don't need to remember the exact slash command. You can also use natural language, such as "save this workflow as a skill" or "extract an instruction from this", and the agent recognizes your intent and starts the correct creation flow.
The same generation options are available from the quick pick menus for prompts, instructions, skills, and agents, indicated by a sparkle icon.
Tools for usages and rename
We have updated the usages -tool and also added a tool for rename. These tools reuse existing extension or LSP capabilities and allow agents to navigate and refactor code with high precision and best performance.Agents should automatically pick up these new tools. However, we have found that agents have a strong preference for using grep instead, which is inferior for this scenario. You can help the agent by explicitly #-mentioning the tool names, like Use #rename and change the name of fib to fibonacci or by setting up a SKILL.md file.
Smarter sessions
Long-running and multi-turn tasks work better when the agent remembers context, delegates research efficiently, and keeps your inline edits in sync. These improvements make sessions more resilient and context-aware.Session memory for plans
Plans created by the Plan agent now persist to session memory and stay available across conversation turns. When you ask for refinements, the agent builds on the existing plan instead of starting from scratch.The plan is also recalled after unrelated messages in the same session, so you can return to a plan without repeating context. During longer implementation work, the plan remains accessible in memory even when older conversation history is compacted to free up context space.
Context compaction
As a conversation grows, the accumulated messages and context can fill up the model's context window. Context compaction summarizes the conversation history to free up space, so you can continue working in the same session without losing important details.VS Code automatically compacts the conversation when the context window reaches its limit, but you can also trigger compaction manually. Manual compaction is available for local, background, and Claude agent sessions. To manually compact, use one of the following methods:
• Type /compact in the chat input field. Optionally, add custom instructions after the command to guide how the summary is generated, for example /compact focus on the database schema decisions.
• Select the context window control in the chat input box, and then select Compact Conversation.Learn more about context compaction in the documentation.
Codebase search with Explore subagent
Setting: chat.exploreAgent.defaultModelThe Plan agent now always delegates codebase research to a dedicated Explore subagent. Explore is a read-only agent that uses only search and file read tools, and focuses on fast, parallelized codebase exploration. By offloading research to Explore, the Plan agent can produce plans that reference specific files and code paths in your workspace.
Explore runs on fast models by default (Claude Haiku 4.5, Gemini 3 Flash) to keep research quick while the Plan agent uses the full model for planning. You can override the model with the chat.exploreAgent.defaultModel setting. Hover over the explore task in chat to see which model is being used for research.
Note: Explore is not directly invokable as a standalone agent. It is only available as a subagent used on-demand.
Inline chat and chat session
When an agent session already changed a file, inline chat now always queues new messages into that session instead of making changes in isolation. This ensures that the full context is used and is also useful when reviewing agent edits.Fork a chat session
You can now fork a chat session to create a new, independent session that inherits the conversation history from the original. This is useful when you want to explore an alternative approach, ask a side question, or branch a long conversation in a different direction without losing the original context.There are two ways to fork a session:
• Fork the entire session: type /fork in the chat input box to create a new session with the full conversation history.
• Fork from a checkpoint: hover over any chat request and select Fork Conversation to create a new session that includes only the conversation up to that point.The forked session is fully independent—changes in one session do not affect the other. Learn more about forking chat sessions.
Chat experience
Small refinements to the chat interface add up: a cleaner model picker, less visual clutter from tool output, and notifications that reach you even when you are heads-down in another file.Redesigned model picker
We have redesigned the language model dropdown to improve selecting the right model for the task. The new dropdown organizes models into clear sections:• Auto is always shown at the top of the list.
• Featured and recently used models appear next. Up to four recently used models are shown alongside featured models curated for your account. As you use models, they move into this section automatically.
• Other models is a collapsible group that contains the remaining available models. Expanding it also reveals the Manage Models option at the bottom.
• A search box lets you quickly filter models by name.Each model entry shows a rich hover with model details such as capabilities and context window size. Models that are unavailable on your current GitHub Copilot plan are also shown but are not selectable.
Discover features with contextual tips (Experimental)
Setting: chat.tips.enabledVS Code now shows contextual tips in the Chat view to help you discover features and get the most out of your AI coding experience. Tips appear when you start a new chat session and are tailored to your usage patterns. To avoid being overwhelming, only features you haven't tried yet are suggested, making them relevant and actionable.
Tips cover a variety of capabilities including:
• Creating custom agents, prompts, and skills
• Using message queueing and steering
• Switching to better models
• Enabling experimental features like YOLO mode and custom thinking phrasesUse the navigation controls to browse through available tips, or dismiss individual tips you're not interested in. Tips automatically hide once you've used the suggested feature. You can disable tips entirely with chat.tips.enabled.
New tips are added regularly as features are released, so check back often for fresh suggestions.
Custom thinking phrases
Settings: chat.agent.thinking.phrasesThe loading text that is shown during reasoning or during tool calls is now customizable. You can use the predefined custom phrases to complete the existing default phrases with the replace mode, or have custom phrases be an addition to the existing default phrases with append.
This setting lets you personalize the chat loading experience.
Collapsible terminal tool calls
Settings: chat.tools.terminal.simpleCollapsibleTerminal tool invocations in agent mode are now displayed as collapsible sections. Instead of long terminal outputs cluttering the conversation, each terminal command appears as a summary header that you can expand to reveal the full output. This reduces visual noise and makes it easier to scan through multi-step agent interactions. This functionality can be disabled with the chat.tools.terminal.simpleCollapsible setting.
OS notifications for chat responses and confirmations
Settings: chat.notifyWindowOnResponseReceived, chat.notifyWindowOnConfirmationPreviously, OS notifications for chat responses and confirmation requests only appeared when VS Code was not focused. This meant that if you were actively working on another task in VS Code, you might miss important updates like when a response is received or when the agent needs your confirmation to proceed.
You can now configure these notifications to appear even when the window is in focus by setting the settings value to always.
Inline chat hover mode
Setting: inlineChat.renderModeInline chat is transitioning away from the "in-between lines" UI to a hover-based UI. You can enable it via inlineChat.renderMode, which makes the inline chat input more like the rename experience. Once a prompt is submitted, progress and results are shown in the upper right corner.
Inline chat affordance
Setting: inlineChat.affordanceTo provide an easier way of starting inline chat, we added two kinds of affordances that show alongside your selection. They combine with the lightbulb and should not get in your way.
The inlineChat.affordance setting has three possible values:
• off No affordance is shown on text selection
• editor Show a menu in the editor alongside the selection
• gutter Show a menu in the editor gutter (line number area) next to the selectionAccessibility
This release improves screen reader support, keyboard navigation, and awareness of chat interactions so that every developer can work effectively with VS Code's AI features.Toggle thinking content in the accessible view
Screen reader users can now toggle the inclusion of thinking content in the chat response accessible view unassigned . This lets you choose whether to include the model's reasoning process when reading responses, providing flexibility to either follow the full chain of thought or focus only on the final output.Question carousel accessibility
The chat question carousel is now fully accessible to screen reader users:
• Questions are announced with their position (for example, "Question 1 of 3")
• Use Alt+N and Alt+P to navigate between questions
• Use unassigned to toggle focus between the question carousel and chat input
• In screen reader mode, focus no longer automatically moves to prevent disruptionNotifications for chat questions and confirmations
Settings: chat.notifyWindowOnConfirmation, accessibility.signals.chatUserActionRequiredWhen chat asks a question or requires confirmation, VS Code now plays an accessibility signal and shows an OS notification when enabled. This helps you stay aware of pending actions even when working in another window.
Keybinding to toggle TODO list focus
Use unassigned to quickly toggle focus between the agent TODO list and the chat input. This is particularly helpful for screen reader users to get an overview of pending tasks and return to the chat input.Cursor position remembered in accessible view
When you close the accessible view while content is streaming (such as during a chat response), your cursor position is now preserved when you reopen it. This prevents the cursor from jumping back to the top and lets you continue reading from where you left off.Find and filter accessibility help
Press Alt+F1 in any find or filter dialog to open contextual accessibility help. This includes help for:
• Editor find and replace
• Terminal find
• Search across files
• Output, Problems, and Debug Console filtersThe help content explains available keyboard shortcuts, navigation patterns, and context-specific behaviors. Find widgets also announce "Press Alt+F1 for accessibility help" when focused (controlled by accessibility.verbosity.find).
Quick input screen reader improvements
The Go to Line dialog ( Ctrl+G ) and other quick input boxes now work better with screen readers:
• Characters are announced as you type
• Arrow key navigation works correctly within the input field
• Proper announcements when navigating list items
• Line and column position announced after navigationSteering indicator for screen readers
When you send a steering message while a response is streaming, screen reader users now receive an aria-status announcement indicating that steering has occurred.Accessibility skill
A new built-in accessibility skill helps ensure new features include proper accessibility support. When you ask the agent to create a new feature and make it accessible, it automatically references accessibility guidelines and patterns.Checkmarks in chat
Settings: accessibility.chat.showCheckmarksThis iteration, in an effort to simplify the chat view and make it more consistent, checkmarks are now removed by default in front of tool calls and collapsible pieces. The accessibility.chat.showCheckmarks will re-enable checkmarks throughout the chat if you'd like to have them as indicators in the chat.
Editor Experience
Modal editors (Experimental)
Settings: workbench.editor.useModal, extensions.allowOpenInModalEditorWe are experimenting with a new modal editor experience for editors that you typically open briefly and then return to your active task. A modal editor floats on top of the editor without impacting the layout of your editor tabs. To close the modal editor, press Escape. The modal has an action to move the editor back into an editor tab, as well as an action to maximize the modal experience.
The modal experience applies to the following editors:
• Settings
• Keyboard shortcuts
• Profiles management
• AI and Language models management
• Workspace trust managementSet workbench.editor.useModal to some for opting into this experience.
Note: the Settings editor and Keyboard Shortcuts editor show a button to open the associated JSON file as a text editor
Another setting extensions.allowOpenInModalEditor expands the use of modal editors to extensions. This experience is still a work in progress and will likely change in the future but we wanted to make it available for feedback now:
In this modal editor, a control in the title bar allows you to navigate between all extensions from the list you had in the Extensions view. The same applies to MCP servers. Future versions will likely see the extensions list and search functionality also move into the modal. Try it out and share your feedback.
Configurable notification position
Setting: workbench.notifications.positionPreviously, VS Code notifications appeared in the bottom-right corner of the screen. With the default position of the Chat view also on the right, notifications could obscure the chat interface.
You can now configure the position of notifications to be either top-right , bottom-right, or bottom-left . The default remains bottom-right . This setting enables you to choose the best position for your workflow.
Settings editor cleanup
We have moved the VS Code chat settings into their own top-level entry in the Settings editor with sub-categories. GitHub Copilot Chat extension entries remain in their own entry under Extensions.The displayed list of settings is also scoped to the selected table of contents entry, meaning that once you select a table of contents entry, you cannot accidentally scroll into the next entry anymore.
Lastly, the experimental settings have been moved to the end of each section, so that stabilized settings appear first.
Code Editing
Long-distance next edit suggestions
Next edit suggestions (NES) extend ghost text by suggesting edits not just at your cursor, but also nearby, anticipating what you'd change next. We've been continuing to advance this experience with long-distance next edit suggestions, which extend NES to predict and suggest edits anywhere in your file, not just near your current cursor position.Read the blog post on long-distance next edit suggestions to learn more about how it was built, from creating the training dataset, to refining the UX, evaluating success, and more. Make sure you have NES ( github.copilot.nextEditSuggestions.enabled ) and extended NES range ( github.copilot.nextEditSuggestions.extendedRange ) enabled in VS Code.
NES eagerness
The Copilot Status Bar item now includes an eagerness option for next edit suggestions. This option lets you choose between getting more suggestions that might be less relevant, or fewer suggestions that are more likely to be useful.Initially, this option primarily affects the timing of suggestions. As the NES model evolves, it will increasingly take your eagerness preference into account for more fine-tuned suggestions.
Source Control
AI co-author attribution for commits
Setting: git.addAICoAuthorVS Code can automatically append a Co-authored-by: trailer when you commit code that includes AI-generated contributions. Additionally, Git blame hover tooltips now show co-authors from commit trailers, including non-AI Co-authored-by entries.
Configure git.addAICoAuthor with one of these values:
• off (default): does not add a co-author trailer
• chatAndAgent: adds the trailer for code generated with Copilot Chat or agent mode
• all: adds the trailer for all AI-generated code, including inline completionsVS Code only adds co-author trailers for commits you make from within VS Code. This setting does not modify commits made in external Git tools or the command line.
Debugging
JavaScript Debugger
Custom property replacements
If an object has a method defined using Symbol.for('debug.properties'), then those properties will be shown by default in the debugger. This allows you to provide a more comprehensible view of complex objects.Emulate focused window and event listener breakpoints
Previously, when debugging a browser, you could set breakpoints in the Event Listener Breakpoints view. We have renamed this view to Browser Options.We added an extra option to Emulate a focused page. When checked, moving your focus out of the browser window no longer causes the browser element to lose focus. This is useful for debugging elements that depend on hover or focus states.
Terminal
Kitty graphics protocol
Settings: terminal.integrated.enableImages, terminal.integrated.gpuAcceleration, terminal.integrated.windowsUseConptyDllThe VS Code terminal now supports the Kitty graphics protocol, enabling high-fidelity image rendering directly in the terminal. Programs that support this protocol can transmit and display images with a rich set of capabilities:
• Image formats: PNG, 24-bit RGB, and 32-bit RGBA
• Display layout: scale images to specific column/row dimensions, crop source regions, apply sub-cell pixel offsets, and control z-index stacking order
• Transmission: direct inline base64 with chunked transfer and zlib compression support
• Image management: transmit and display in one step, store images and place them later at different positions, delete by ID or all at once, and re-transmit to update existing images
• Cursor control: choose whether the cursor moves past the image or stays in place after rendering
• Terminal integration: images scroll with text, and are properly cleaned up on terminal reset or clearTo enable image rendering, set terminal.integrated.enableImages to true and ensure terminal.integrated.gpuAcceleration is set to on or auto. On Windows, you also need to enable terminal.integrated.windowsUseConptyDll.
Tools like kitten icat (macOS/Linux) or the VT CLI can be used to display images in the terminal.
Note: Some Kitty graphics protocol features are not yet supported, including animations, relative placements, Unicode placeholders, and file-based transmission. See the xterm.js discussion for the most up-to-date implementation status.
Ghostty support for external terminal
Settings: terminal.external.osxExec, terminal.external.linuxExecGhostty is now supported as an external terminal on macOS and Linux. You can set it as your default external terminal using the terminal.external.osxExec setting on macOS or terminal.external.linuxExec on Linux.
Once configured, commands like Terminal: Open New External Terminal and debug configurations that launch in an external terminal will open in Ghostty.
Workspace folder selection for external terminals
When you open an external terminal in a multi-root workspace using Ctrl+Shift+C or the Terminal: Open New External Terminal command, VS Code now prompts you to select a workspace folder. The selected folder is used as the working directory for the external terminal.Terminal sandboxing improvements (Preview)
Settings: chat.tools.terminal.sandbox.enabled, chat.tools.terminal.sandbox.linuxFileSystem, chat.tools.terminal.sandbox.macFileSystem, chat.tools.terminal.sandbox.networkTrusted domains can now be selected for network isolation by enabling allowTrustedDomains in chat.tools.terminal.sandbox.network. Improved detection of restricted domains, with clear feedback indicating which domain is blocked.
No installation is required to enable terminal sandboxing on macOS, and on Linux you can enable without installing ripgrep.
Languages
Unified JavaScript and TypeScript settings
To prepare for the upcoming TypeScript 6.0 and 7.0 releases, we've consolidated and cleaned up our built-in JavaScript and TypeScript setting IDs. Previously many of these settings had duplicate javascript.* and typescript.* versions. This is because these settings are from before we added a standard approach to language-specific settings. Some of the settings names were also inconsistent.Now all of these settings have been moved under the js/ts.* prefix. This means that by default you only need to update a single setting value to change the behavior in both JavaScript and TypeScript files. You can use language-specific settings if you want different behavior in JavaScript and TypeScript files.
For example, instead of setting:
"javascript.format.enable": false,
"typescript.format.enable": trueYou can now use language-specific overrides with the unified setting.
The old javascript.* and typescript.* settings continue to work but are now marked as deprecated and will be overridden if the new unified js/ts settings are set.
We understand this is a big change, however we think it's the right one for the long term quality of VS Code. The unified settings make it easier to change JavaScript and TypeScript settings, and also enable support for modern options such as language-specific settings.
Python
Python Environments extension rolling out to all users
The Python Environments extension is now rolling out to all users after a year in preview. The extension brings a unified interface for managing Python environments, packages, and interpreters directly in VS Code, regardless of whether you use venv, conda, pyenv, poetry, or pipenv.Key capabilities include:
• Quick Create: Create an environment with a single click using your default manager and the latest Python version
• Python Projects: Assign environments to specific folders for monorepos and multi-service workspaces
• uv integration: Faster environment creation and package installation when uv is installed
• Built-in package management: Search, install, and uninstall packages from the Environment Managers view
• Portable settings: Environment configurations use manager types instead of hardcoded paths, making settings.json portable across machinesYou can expect the extension to be enabled automatically over the next few weeks, or you can opt in immediately with the python.useEnvsExtension setting.
For more details, read the announcement blog post or see the Python environments documentation.
Contributions to extensions
GitHub Pull Requests
There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
• Multiple pull request and issue descriptions can be open at once.
• The setting githubPullRequests.autoRepositoryDetection can be set to true to include repositories that are outside of the workspace.
• Repositories without matching issues are now hidden in the Issues view.Review the changelog for the 0.130.0 release of the extension to learn about everything in the release.
Extension Authoring
Webviews and Custom Editors can now use ThemeIcons for their icon path
Webview Panels and custom editors can now use a ThemeIcon as their editor tab icon.Portable mode detection API finalized
The env.isAppPortable API is now stable and available to all extensions without requiring enabledApiProposals.Use this API to detect whether VS Code is running in portable mode, which is enabled when the app runs from a folder containing a data directory.
Proposed APIs
Chat item controller API
We continued to improve the chat session API. This API lets extensions contribute items to VS Code's built-in chat sessions view. Notable changes this iteration include:
• Added ChatSessionItemControllerNewItemHandler so that controllers can specify the URI used for new sessions.
• Added ChatSessionProviderOptions.newSessionOptions which sets the default options for new sessions.We also significantly optimized the API's implementation to support large numbers of sessions.
Engineering
TypeScript-Go for VS Code engineering
We've continued adopting TypeScript-Go (tsgo) for development work in the vscode repo.As of this iteration, we default the vscode workspace to using TSGo for development. We've already noticed performance improvements from this, and it also helps us test TSGo's language tooling.
We now also use TypeScript-Go (tsgo) to compile VS Code's built-in extensions during development. As a result, each of our built-in extensions is now built and fully typechecked in under a second.
Extension bundling with esbuild
We've migrated most of our built-in extensions to use esbuild instead of webpack for bundling. Esbuild is used for both bundling the desktop and web versions of these extensions.This migration has both simplified and sped up our builds. There are only a handful of extensions left to migrate and we hope to finish this work in March.
Deprecated features and settings
New deprecations in this release
• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.Upcoming deprecations
NoneNotable fixes
• vscode#251722: Inline actions on extension provided tree-view items withing the visible scroll area even when "workbench.list.horizontalScrolling": trueThank you
Issue tracking
Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @tamuratak (Takashi Tamura)
• @robotsnh (robotsnh)(Additional contribution and PR acknowledgements follow in the release notes.)
We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.
If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.
Original source Report a problem - Mar 3, 2026
- Date parsed from source:Mar 3, 2026
- First seen by Releasebot:Mar 4, 2026
Version 2602: March 03
Version 2602 (Build 19725.20152)
Resolved issues
Office suite
- Fixed an issue where closing a document could in rare cases remain in progress indefinitely after the app resumed from sleep or hibernation.
- Mar 2, 2026
- Date parsed from source:Mar 2, 2026
- First seen by Releasebot:Mar 3, 2026
Windows news you can use: February 2026
February 2026 Windows update unleashes new Start menu customization, Windows 365 enhancements, Secure Boot monitoring tools, and AI/Copilot updates along with security improvements. Live tech events and an upcoming Secure Boot AMA amplify deployment and governance with on‑demand sessions.
Welcome to the February 2026 edition of Windows news you can use. Today marks the start of Microsoft Technical Takeoff—four Mondays of demos, deep dives, and live Q&A for the IT pro community. If you're not tuning in live, all sessions will be recorded, so definitely bookmark any topics of interest and catch up on demand.
Speaking of events, we're hosting another Secure Boot AMA on March 12. Post your questions in advance or during the live event. New and updated resources and tools help you monitor the status of Secure Boot certificate updates across your estate. Look for more details on those below.
New in Windows update and device management
- [BACKUP] [RESTORE] – The first sign-in restore experience is now part of Windows Backup for Organizations. Empower people to restore their settings and Microsoft Store app list automatically at first sign-in, including those using Microsoft Entra hybrid joined devices, Cloud PCs, and multi‑user devices. For the first time, users who sign in with a Microsoft Entra ID on eligible devices will be able to restore their environment if they missed the option during first sign-in.
- [START MENU] – The new Start menu will be available to organizations in the second quarter of this calendar year. Two policies allow IT admins to further customize the Start menu: HideCategoryView and ConfigureStartPins. For more details, see the Start Policy CSP and Start policy settings.
- [WINDOWS 365] – By pairing Windows 365 Reserve with Windows 365 Boot, you can keep Windows 11 devices preconfigured with Windows 365 Boot. When users need access, simply assign a Windows 365 Reserve license in Microsoft Intune and hand the device to a user. No additional setup required.
- [WINDOWS 365] – Windows 365 is now supported in New Zealand North. This supports organizations who need to keep data within national borders, meet industry or government compliance expectations, or simply provide your workforce with a faster, more consistent Cloud PC experience.
- [26H1] – Windows 11, version 26H1 is a targeted release designed to support the next generation of silicon. Find out what you need to know about version 26H1 and why Windows 11, versions 25H2 and 24H2 remain the recommended releases for enterprise deployment.
- [ADMIN] – Learn how to filter and focus Message center in the Microsoft 365 admin center to prioritize Windows information with a new step-by-step guide.
- [WINDOWS] [5G] – Windows enterprise managed cellular connectivity is in private preview. This native Windows capability provides organizations with centralized management and customization of 5G cellular connectivity on Windows 11 PCs. This solution is integrated with Intune and validated on Surface 5G-enabled devices (available now).
New in Windows security
- [SECURE BOOT] – New tools and guidance are available to help you actively monitor and manage the update of Secure Boot certificates across your device fleet.
- Explore the latest OEM pages for Secure Boot.
- Find out what happens when Secure Boot certificates expire on Windows devices.
- Quickly get a device-level view of Secure Boot across your Windows Autopatch-managed devices with the Secure Boot status report.
- For devices not enrolled in Windows Autopatch, learn how to monitor Secure Boot certificate status with Microsoft Intune remediations.
- Access tailored guidance for managing Secure Boot certificate updates for Windows Server, Windows 365, and Azure Virtual Desktop.
- Review updated FAQs about the Secure Boot update process.
- Stay updated as new resources become available by bookmarking the new Updates and announcements section of https://aka.ms/GetSecureBoot.
- Tune in live—and post your questions in advance—for the March 12 Secure Boot Ask Microsoft Anything session on the Microsoft Tech Community. Want a primer before the AMA? Tune in March 9 to Secure Boot certificates explained at Tech Takeoff.
New in AI
- [MECHANICS] – For those seeking to better understand Microsoft 365 Copilot and AI experiences on Windows 11 PCs, check out the new episode of Microsoft Mechanics. See how to access Copilot and agents from the taskbar. Find answers across files, email, and meetings, and turn ideas into polished content using voice or text.
To learn about latest capabilities for Copilot+ PCs, visit the Windows Roadmap and filter Platform by “Copilot+ PC Exclusives.”
New in productivity and collaboration
Install the February 2026 security update for Windows 11, versions 25H2 and 24H2 to get these and other capabilities.
- [SECURITY] – You can now set how often Data Protection Application Programming Interface (DPAPI) domain backup keys rotate automatically. This strengthens cryptographic security and reduces reliance on older encryption algorithms.
- [MOBILE] – Cross‑Device Resume now includes the ability to continue activities from your Android phone on your PC based on the apps and services you use. Resume Spotify playback, work in Word, Excel, or PowerPoint, or continue a browsing session.
- [ACCESSIBILITY] – Narrator now gives you more control over how it announces on‑screen controls. You can choose which details are spoken and adjust their order to match how you navigate apps.
New features and improvements are coming in the March 2026 security update. You can preview them by installing the February 2026 optional non-security update for Windows 11, versions 25H2 and 24H2. This update includes the gradual rollout of:
- [RECOVERY] – Quick Machine Recovery now turns on automatically for Windows Professional devices that are not domain‑joined and not enrolled in enterprise endpoint management. These devices receive the same recovery features available to Windows Home users. For domain‑joined or enterprise managed devices, Quick Machine Recovery stays off unless you enable it for your organization.
- [NETWORK] – A built‑in network speed test is now available from the taskbar. The speed test opens in the default browser and measures Ethernet, Wi‑Fi, and cellular connections.
- [CAMERA] – Control pan and tilt for supported cameras in the Settings app.
- [SYSMON] – System Monitor (Sysmon) functionality is now natively available in Windows. Capture system events for threat detection and use custom configuration files to filter the events you want to monitor. Windows writes captured events to Windows Event Log, which allows security tools and other applications to use them.
- [SEARCH] – When using search on the taskbar, preview search results by hovering and quickly seeing when more results are available with group headers.
- [RSAT] – This update adds support for Remote Server Administration Tools (RSAT) on Windows 11 Arm64 devices.
New for developers
- [STORE] – Explore new features and updates for those developing for the Microsoft Store on Windows. Check out developer analytics, a web installer, and new developer tools.
New in Windows Server
For the latest features and improvements for Windows Server, see the Windows Server 2025 release notes and Windows Server, version 23H2 release notes.
- [SECURE BOOT] – The original Secure Boot certificates introduced in 2011 are approaching the end of their planned lifecycle, with expirations beginning in late June 2026. While many recent platforms include the supported 2023 certificates in firmware, you'll need to manage the process manually for any that require updating. Get started today with the Windows Server Secure Boot playbook for certificates expiring in 2026.
- [ReFS] – Resilient File System (ReFS) boot support is now available for Windows Server Insiders in Insider Preview builds.
- [DNS] – A public preview of DNS over HTTPS (DoH) for Windows DNS Server is now available. DoH support in Windows DNS Server complements broader Zero Trust DNS efforts already introduced on Windows clients to enable organizations to adopt encrypted, authenticated DNS across endpoints and on-premises infrastructure.
- [WS2025] – Looking for help with capacity planning of Remote Desktop Session Host servers running Windows Server 2025? Check out the new guide.
Lifecycle milestones
- Windows 10 Enterprise 2016 LTSB and Windows 10 IoT Enterprise 2016 LTSB will reach end of support on October 13, 2026. Windows Server 2016 will reach end of support on January 12, 2027. If your organization cannot migrate to newer, supported releases in time, explore the options available to help you keep your devices protected with monthly security updates.
Check out our lifecycle documentation for the latest updates on Deprecated features in the Windows client and Features removed or no longer developed starting with Windows Server 2025.
Additional resources
Looking for the latest news and previews for Windows, Copilot, Copilot+ PCs, the Windows and Windows Server Insider Programs, and more? Check out these resources:
- Windows Roadmap for new Copilot+ PCs and Windows features – filter by platform, version, status, and channel or search by feature name
- Microsoft 365 Copilot release notes for latest features and improvements
- Windows Insider Blog for what's available in the Canary, Dev, Beta, or Release Preview Channels
- Windows Server Insider for feature preview opportunities
- Understanding update history for Windows Insider preview features, fixes, and changes to learn about the types of updates for Windows Insiders
Join the conversation
If you're an IT admin with questions about managing and updating Windows, add our monthly Windows Office Hours to your calendar. We assemble a crew of Windows, Windows 365, security, and Intune experts to help answer your questions and provide tips on tools, best practices, and troubleshooting.
Finally, we're always looking to improve this monthly summary. Drop us a note in the Comments and let us know what we can do to make this more useful for you!
Continue the conversation. Find best practices. Bookmark the Windows Tech Community, then follow us @MSWindowsITPro on X and on LinkedIn. Looking for support? Visit Windows on Microsoft Q&A.
Original source Report a problem - Mar 2, 2026
- Date parsed from source:Mar 2, 2026
- First seen by Releasebot:Mar 3, 2026
Windows Autopatch update readiness brings insights to IT
Windows Autopatch update readiness is GA with new proactive update management features. It adds a management status report, end‑to‑end update journey, alerts and remediation, plus a readiness checker to reduce downtime and boost compliance across devices.
What’s new in Windows Autopatch update readiness?
We’re excited to announce the general availability (GA) of Windows Autopatch update readiness, bringing a new level of clarity, control, and confidence to your update management experience. This release is designed to help you anticipate issues, streamline deployments, and maintain organizational resilience, all within your existing Windows Autopatch license.
Windows Autopatch is available for customers with Windows Enterprise, Frontline, US Government, Education and Business Premium SKUs. Learn more here.
Windows Autopatch update readiness brings new capabilities to help you proactively detect and remediate device update issues, so you can reduce downtime, improve update success, and lower the security risk that comes from devices that aren’t up to date. As part of this release, you’ll see four core experiences added to Windows Autopatch:
- Windows Autopatch management status report – A tenant-wide view of Windows update management coverage across your Intune-enrolled Windows devices.
- Quality update journey – End-to-end, per-device visibility into where an update is in the lifecycle and what’s blocking progress.
- Alerts and remediations – A centralized, actionable alerts experience with clear guidance to drive issues to resolution.
- Update Readiness Checker – Proactive checks to identify devices at risk before updates roll out widely.
Windows Autopatch management status report: Tenant-wide coverage at a glance
The Autopatch management status report gives you a tenant-wide, device-centric view of all Intune-managed Windows 10 and Windows 11 devices including devices enrolled in Windows Autopatch, devices managed by update rings, and devices not currently under any update policy. This helps you quickly spot gaps in update management coverage, so devices don’t quietly fall through the cracks.
At a glance, this report helps you understand:
- Your full device inventory of Intune-managed Windows devices.
- Whether devices are enrolled in Windows Autopatch cloud approval policies for feature, quality, and driver updates.
- How devices are managed for updates—via update rings or categorized as Other (Intune-enrolled but not part of cloud policies or update ring policies).
- Whether a device is enrolled in hotpatch updates (part of the Windows quality update policy with the “Allow rebootless updates” toggle enabled).
- Whether there are active alerts associated with a device.
Quality update journey: Pinpoint where updates stall
The Quality update journey report provides end-to-end, per-device visibility into how a Windows device progresses through an update, providing clear, granular phases. Instead of guessing, you can see what a device has already completed, where it is currently paused, and where it may be encountering issues.
Presented as a per-device timeline, the report traces each stage of the update lifecycle from offering to download, install, reboot, and completion, including timestamps, state transitions, and mapped alerts so you can follow a trustworthy sequence of events.
With this view, you can more easily spot patterns across devices (for example, many devices pausing in the same phase) and focus your troubleshooting where it will have the biggest impact. In this GA release, Device Update Journey initially focuses on Windows feature updates.
Repair with confidence
You can spot devices that need repair, identify any that might face update blockers, and use targeted remediations to stay secure, all through Windows Autopatch. Actionable alerts guide administrators through each step, while integrated audit logs ensure you’re aware of what’s occurred and progress is transparent.
Actionable alerts, transparent progress
When something needs your attention, Windows Autopatch makes sure you’re in the loop with actionable alerts and guided remediation. Each step is tracked, leading to a clearer IT backlog and measurable gains in compliance. Best of all? These features work with your current deployment process — no need to change how you roll out updates.
Available as part of your existing Autopatch license
All these capabilities are available today as part of your existing Windows Autopatch license—no add-ons, no extra purchases, and no disruption to your current workflows. Windows Autopatch update readiness is designed to deliver immediate value by helping IT teams reduce manual preparation and troubleshooting, improve update success rates, and quickly bring at-risk devices back into compliance.
Ready to elevate your update experience? Start benefiting from Windows Autopatch update readiness today and empower your IT teams with proactive insights and streamlined control. For more information, visit the Windows Autopatch portal or reach out to your Microsoft representative.
- Start using Windows Autopatch now.
- Learn how to upgrade to Windows 11 using Windows Autopatch.
- Join the Microsoft Security Advisors Program for exclusive opportunities to help shape our product, get early access to the roadmap, and connect with a community of IT professionals.
Continue the conversation. Find best practices. Bookmark the Windows Tech Community, then follow us @MSWindowsITPro on X and on LinkedIn. Looking for support? Visit Windows on Microsoft Q&A.
Original source Report a problem - Feb 27, 2026
- Date parsed from source:Feb 27, 2026
- First seen by Releasebot:Feb 28, 2026
Dynamics 365 Finance by Microsoft
Building Smarter Observability for Agentic ERP World using Dynamics 365
Dynamics 365 ERP adds expanded batch telemetry to Azure Application Insights, including start/stop, failures, throttling, thread and queue metrics. This gives deeper visibility, faster troubleshooting, and smarter capacity planning for batch workloads.
Why Observability Matters Now
As enterprise workloads become more agentic, the expectations of ERP systems—and the teams that operate them—are shifting. Batch jobs, workflow orchestration, data import/exports, and background processes are no longer “just” technical plumbing–they are critical pieces of the operational fabric. They deliver timely financial results, accurate supply chain data, and reliable business intelligence driving process optimization.
To support this shift, observability needs to evolve beyond simple logs and reactive troubleshooting. Observability needs to provide meaningful insights into execution behavior, performance patterns, and operational context. This ensures IT teams can run ERP with confidence and reliability.
In Dynamics 365 ERP apps, we’ve long provided integration with Azure Application Insights to help organizations collect telemetry about user activity, failures, and application behavior. Now, with the expansion of batch telemetry signals — including start/stop events, failure data, throttling conditions, thread availability, and queue behavior — administrators and IT architects can gain deeper visibility into the health of critical batch-based workloads.
What Batch Telemetry Brings to the Table
The monitoring and telemetry capabilities in Dynamics 365 ERP enable customers to send application telemetry to Azure Application Insights for analysis and alerting. The recent expansion of telemetry signals for batch workloads builds on this foundation by adding behavioral data specifically for batch execution patterns.
These signals include:
- Batch start and stop events to show how long jobs take to run, not just whether they completed.
- Failure information that correlates with info log entries and execution context.
- Throttling indicators that highlight contention due to system load.
- Thread availability data that helps reveal when jobs are waiting because capacity is constrained.
- Queue depth metrics shows number of waiting tasks for all queues that are part of the Priority Based Scheduling queues.
Emitting these signals into a customer-owned Application Insights resource means teams can apply their existing monitoring pipelines, dashboards, and alerting logic without changing how data is consumed.
From Visibility to Insight
Once batch telemetry data flows into Application Insights, teams can query it using Kusto Query Language (KQL) and build dashboards that correlate workload behavior with other operational metrics.
This richer observability enables several practical outcomes:
- Faster investigation of execution behavior without sifting through logs.
- Trend analysis to detect regressions or capacity bottlenecks before they impact business cycles.
- More informed capacity planning based on actual observed patterns.
- Alignment of SLA expectations with real operational performance.
Here are some real‑world business scenarios that show how telemetry insights are helping customers troubleshoot issues and resolve problems faster.
A global consumer goods company frequently sees high priority jobs completing late. Batch Queue telemetry exposes queue congestion and thread exhaustion, showing when noncritical tasks bury priority workloads.
It helps surface when priority-based scheduling queues build up and delay time‑sensitive workloads, while also revealing misconfigured priorities that cause jobs to be processed out of order. It further enables teams to closely monitor queue health during cutover or high‑load events, ensuring critical workloads flow smoothly.Similarly, a finance team’s bank reconciliation jobs remain “Waiting” for long periods. Thread telemetry reveals thread starvation—jobs were queued, but threads were fully consumed.
It helps explain why jobs remain stuck in a “Waiting” state by revealing when thread capacity is fully consumed by parallel workloads. It also highlights thread saturation patterns, enabling teams to right‑size AOS batch capacity for smoother, more predictable processing.A Foundation for Intelligent Operations
The expanded telemetry signals are not just a diagnostic tool. They serve as a foundation for smarter operations in an era where agents play an increasing role. High-fidelity Batch telemetry enables experiences like:
- Automated detection of anomalies based on execution baselines.
- Correlation of workload performance with business-critical thresholds.
- Enhanced alerts that tie operational conditions to business impact.
By making execution behavior more observable and actionable, Dynamics 365 ERP helps teams focus on outcomes, not just symptoms.
Getting Started
If you haven’t already configured monitoring and telemetry for your environment, the first step is to integrate your Dynamics 365 ERP instance with Azure Application Insights – refer.
Monitoring and telemetry overview – Finance & Operations | Dynamics 365 | Microsoft Learn.
Once telemetry is configured, expanded batch signals can be toggled on from within system administration and begin flowing to your Application Insights pipeline for analysis.
Rich observability is a core requirement for running modern ERP workloads, especially as organizations adopt more automation and begin exploring agent-assisted operational tooling. By bringing deeper insight into batch execution behavior, our ERP portfolio apps in Dynamics 365 helps IT teams move from reactive troubleshooting toward proactive reliability and informed decision-making.
For more details visit Available telemetry – Finance & Operations | Dynamics 365 | Microsoft Learn.
Original source Report a problem