is now available! Read about the new features and fixes from October.

October 2025 (version 1.106)

Release date: November 12, 2025

Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap

Welcome to the October 2025 release of Visual Studio Code.

Graphic showing the key highlights of the October 2025 release: Agent HQ, Security and trust, and great editor experience.

This releases brings significant updates across three key areas:

  • Agent HQ is your single view to kick off, monitor, and review agent sessions, whether they're local or remote, from Copilot or OpenAI Codex
  • Security and trust help you stay in control and confidently delegate more tasks to AI
  • A great editor experience to make your day-to-day coding smoother and more enjoyable

Happy 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.
Download Insiders

Agents

Agent Sessions view

Setting: chat.agentSessionsViewLocation

As you hand off tasks to various coding agents, it's important to have a clear overview of all your active sessions. The Agent Sessions view provides a centralized location for managing your active chat sessions. This includes both local sessions in VS Code and sessions created by background agents in other environments, such as Copilot coding agent, GitHub Copilot CLI, or OpenAI's Codex. The Agent Sessions view is now enabled by default, and can be managed via the chat.agentSessionsViewLocation setting.

By default, the Agent Sessions view lists all your active chat sessions organized by their source. The view is divided into sections for local chat sessions in VS Code and for background agent sessions:

Screenshot of the Agent Sessions view in the Primary Side Bar, showing a view for local chat sessions, and coding agents like Copilot coding agent, Copilot CLI and Codex.

If you prefer to have one consolidated view of your sessions across all providers, you can enable the single-view option for the chat.agentSessionsViewLocation setting. This option also moves the Agent Sessions view next to the Chat view in the Secondary Side Bar, making it easier to switch between chat and managing your sessions.

Note that not all functionality is available in the consolidated view yet. We are actively working on making this view the default in the near future.

The Agent Sessions view now also supports search (⌥⌘F (Windows, Linux Ctrl+Alt+F)) to help you easily find your sessions in the list.

Learn more about the Agent Sessions view in the VS Code documentation.

Plan agent

A new plan agent helps developers break down complex tasks step-by-step before any code is written. Select Plan from the agents dropdown in the Chat view to get started. When tackling a multi-step implementation, VS Code prompts you with clarifying questions and generates a detailed implementation plan that you approve first, ensuring all requirements and context are captured upfront.

We recommend spending time iterating on the plan before implementation. You can refine requirements, adjust scope, and address open questions multiple times to build a solid foundation. Once you approve the plan, Copilot implements it either locally in VS Code or via cloud agents, giving you greater control and visibility into the development process. This helps you catch gaps or missing decisions early, reducing rework and improving code quality.

You can also create your own custom plan agent tailored to your team's specific workflow and tools. Use the Configure Custom Agent menu to copy the built-in plan agent as a starting point, then customize the planning style, tools, and prompts to match your development process. Learn more about planning in VS Code chat and creating custom agents.

Cloud agents

In this release, we have made quite a few updates to cloud agent sessions in the editor.

We migrated the Copilot coding agent integration from the GitHub Pull Request extension into the Copilot Chat extension to provide a more native cloud agent experience in VS Code. This integration paves the way for smoother transitions and interactions between VS Code and GitHub Mission Control, such as opening a cloud agent session directly from the Agent Sessions view in the browser and vice versa.

CLI agents

In this release, we have also shipped an initial integration with the Copilot CLI. You can create new and resume existing CLI agent sessions in a chat editor or an integrated terminal.

Screenshot of the CLI dropdown menu showing options to create a new CLI agent session or resume an existing one.

In a CLI agent editor, you can send messages to the Copilot CLI just as you would in a terminal, switch models, and attach context.

Screenshot showing a CLI agent editor and an integrated terminal with Copilot CLI sessions.

Agent delegation

We continue to improve the experience for delegating to cloud agents.

When you use the cloud button to delegate to an agent from the chat panel, you'll be provided a set of available agents to which you can delegate. You can also delegate to the Copilot coding agent from the CLI, via the /delegate command in a CLI editor or terminal instance.

Screenshot showing delegating from a CLI agent editor.

CLI agent edit tracking

Chat edit sessions now track edits made by background agents, such as the Copilot CLI. When you create sessions from the Agent Sessions view, you can see edits tracked through both inline edit pills and the working set view, making it easier to understand what changes agents are making to your workspace.

Chat modes renamed to custom agents

Chat modes have been renamed to custom agents throughout VS Code to better align with terminology used in other environments.

Screenshot of the agent picker control.

When you create custom agents, the definition files are now located in .github/agents in your workspace. These files can use the .agents.md suffix and can also be used as Github Copilot Cloud Agents and CLI Agent.

Use Chat: New Custom Agent... to create a new agent and Chat: Configure Custom Agents... to manage them.

If you have existing custom chat modes (.chatmode.md files in .github/chatmodes), they continue to work and are automatically treated as custom agents. When you open a chat agent file in the editor, a info marker appears on the first line with a quick fix to migrate it to a custom agent file.

Custom agent metadata

Custom agent .agent.md files now accept an additional target frontmatter property to describe how an agent should run across environments:

  • target: vscode: optimizes the agent for local chat and unlocks name, description, argument-hint, model, tools, and handoffs properties. Any tool installed in VS Code can be used.
  • target: github-copilot: prepares the agent for Copilot cloud agents or the GitHub CLI with support for name, description, tools, mcp-servers, and target. Tools can be edit, search, shell, custom-agent, and tools from MCP servers

All agents can be run in all environments. Each environment ignores unknown attributes and tools.

  • name: lets you override the agent label without renaming the file.
  • argument-hint: surfaces guidance in the chat input so teammates know how to prompt the agent.
  • handoffs: wires guided transitions to other agents, letting you chain multi-step workflows.

The agent file editor provides validation, code completions, hovers and code actions.

GIF of validation while editing custom agent files.

Learn more about custom agents and agent handoffs in our documentation.

Code Editing

Deleted code in diff editor is now selectable

Previously, when you deleted code and viewed the changes in the diff editor, you couldn't copy those deleted lines. In this release, you can now select and copy text from deleted lines in the diff editor when using the inline diff view.

Inline suggestions are open source

This release continues our journey to make VS Code an open source AI editor. Following our first milestone of open sourcing GitHub Copilot Chat, we've now open sourced inline suggestions by merging them into the vscode-copilot-chat repository.

As part of this milestone, we're consolidating the GitHub Copilot extension and GitHub Copilot Chat extension into a single extension experience. The Chat extension now serves all inline suggestions, providing the same intelligent code suggestions you're used to while maintaining all chat and agent functionality. The change should be transparent, you'll continue getting the same code suggestions as you type. If you encounter any issues, you can temporarily revert using the chat.extensionUnification.enabled setting.

The GitHub Copilot extension will be deprecated by early 2026. Learn more about this milestone and explore the open source code in our blog post.

Snooze inline suggestions from gutter

You can now snooze inline suggestions directly from the gutter icon. When you hover over the gutter icon, a control appears with a Snooze option. Select it and choose a duration to pause suggestions.

Screenshot showing the Snooze button in the gutter context menu for inline suggestions.

Go to line improvements

This iteration, we've made several enhancements to the Go to Line command (⌃G (Windows, Linux Ctrl+G)), improving navigation within files.

The Go to Line command now supports navigating to a specific character position in a file by using the :: syntax. This is useful when tools report errors at specific character offsets, such as "error at position 599".

To navigate to a character offset, type :: followed by the character number in the Go to Line input box. For example:

  • ::599 - Navigate to character 599 in the file
  • ::-100 - Navigate 100 characters from the end of the file

Use the toggle in the input box to switch between 1-based (default) and 0-based offset calculations.

In addition, the Go to Line command also handles out-of-range values more gracefully and makes it easier to navigate to the start or end of files and lines:

  • Line numbers: Typing a line number larger than the file's line count navigates to the last line.
  • Column numbers: Using negative column numbers navigates from the end of a line. For example, :12:-1 takes you to the last character on line 12. Typing a column number larger than the length of the line takes you to the end of the line.

Editor Experience

Refreshed iconography

In this release, the codicon icon set has had a facelift. The new icons have been refined with curves, new modifier designs, and more accurate metaphors to make them feel modern, friendly and more legible.

Screenshot of updated product icons showing a more modern appearance and increased legibility.

Linux policy support

We've introduced support for managing VS Code policies on Linux systems using JSON files. This allows administrators to enforce specific settings and configurations across all users on a Linux machine.

For more details, see JSON Policies on Linux.

Navigate changes in multi file diff editor

Just like you can navigate to next or previous changes in a diff editor for a single file, you can now do so across files in the multi-file diff editor. Use keybindings or the navigation up and down arrow keys to review your changes across files.

Copy diagnostic hover text

A copy button now appears in diagnostic hovers (errors, warnings, info, and hints) to make copying error messages easier. When you hover over a diagnostic marker, move your mouse over the hover message to reveal a copy button in the top-right corner.

Screenshot of hovering over a diagnostic hover revealing a copy button in the top-right corner.

Accent-insensitive command filtering

The Command Palette now ignores character accents when searching for commands, making it easier to find what you need regardless of your keyboard layout or language preferences. For example, when searching for a command containing the word Générer (French for Generate), type generer without accents and matching commands appear in the results.

This is helpful when using different keyboard layouts or when mistyping while looking for a command. The filtering is based on Unicode Normalization Form D and supports all Unicode languages.

Advanced VS Code settings

VS Code now supports the concept of advanced settings. These settings are meant for configuring specialized scenarios and are intended for advanced users who need fine-grained control over their environment. By default, advanced settings are hidden in the Settings editor, keeping the interface streamlined while making these powerful options available when needed.

To view and configure advanced settings, select Advanced from the filter dropdown menu in the Settings editor, or type @tag:advanced in the search box:

Screenshot showing the Settings editor with the Advanced filter applied, displaying advanced settings with the Advanced tag badge

When you search for a specific setting by its exact name or use the @id: filter, advanced settings appear in the results without having to apply the Advanced filter. This ensures you can always find the settings you're looking for.

Advanced settings can be combined with other filters such as @modified or @feature: to help you find exactly what you need. For example, @tag:advanced @feature:terminal shows only advanced settings related to the terminal.

Note: Extension authors can mark their settings as advanced by adding the advanced tag to the setting configuration.

Chat

Embeddings-based tool selection

In this release we've significantly improved how we filter and group tools for users that have many (over 100) tools enabled in chat. You should see the "Optimizing tool selection..." loading state less often and for a shorter period of time. We also improved tool selection with a lower probability of agent confusion to make sure the right tools are chosen.

Tool approvals and trust

Post-approval for external data

Agent tools that pull in external data now support post-approval. This helps protect against potential prompt injection attacks by letting you review the data before it's used in your chat session.

Post-approval is enabled for the #fetch tool and for Model Context Protocol (MCP) tools that declare openWorldHint.

Trust all tools for a server or extension

You can now trust MCP servers and extension tools at the source level through the Allow button dropdown. This means that you can approve all tools from a specific MCP server or extension at once, rather than having to approve each tool individually.

We have also updated the Chat: Manage Tool Approval command experience to let you manage both pre- and post-approval of tools.

Screenshot of the Manage Tool Approval command experience, enabling tools to skip approval and skipping content review.

Tool auto approval status moved

Auto approval status has moved from being inline inside the chat view to the tool call status/tick icon:

Screenshot of hovering a tool's tick icon will reveal why it was auto approved

Terminal tool

Auto approve parser improvements

Previously, subcommand detection in the terminal tool used the naive approach of just splitting on certain strings such as | or &&. This failed in several ways but the bigger ones were when pipe was used inside strings like echo "a|b|c", which would detect the subcommands echo, b and c". Another important one is that since we couldn't reliably pull subcommands, we outright banned paranthesis pairs, curly brace pairs, and backticks to be more on the safe side and prevent accidental execution.

This release, we integrated a parser into the feature and use a PowerShell grammar or a bash grammar for everything else*. So, even really complex cases should be correctly extracted:

Screenshot of detecting "$()" inside echo calls.

* Note that this means it can fail to catch subcommands when the shell syntax differs from bash, such as ; in zsh

File write/redirection detection (Experimental)

Thanks to the new parser, we're able to fairly reliably extract files being written to via redirection. There's the new experimental setting chat.tools.terminal.blockDetectedFileWrites that will prevent auto approval conditionally.

Screenshot showing that writing outside the workspace by default will block auto approval.

Disable default auto approve rules (Experimental)

The new experimental setting chat.tools.terminal.ignoreDefaultAutoApproveRules allows disabling the default rules (both allow and deny rules). This is useful if you want more control without needing to look up the defaults.

Shell specific prompts and command rewriting

The terminal tool now has shell-specific descriptions for PowerShell, bash, zsh and fish. This should make commands suggested by the agent more reliable and less likely to fail, especially for PowerShell.

In addition to this, for PowerShell we also re-write && to ; since the && chain operator is not supported in Windows PowerShell (v5). Note that this is temporarily also happening for PowerShell 7 until vscode#274548 is actioned.

Attach terminal commands to chat

You can now attach a terminal command to chat as context from the command decoration's context menu. The attachment shares the command line, captured output, and exit code so the agent understands precisely what happened. This applies to any command tracked by shell integration, making it easy to escalate troubleshooting without copying and pasting text.

View terminal output inside chat (Experimental)

The new chat.tools.terminal.outputLocation setting controls where the output is displayed. The default none value prevents the terminals from cluttering the panel.

Every chat terminal invocation now surfaces two actions on the progress element:

  • Show Terminal reveals and focuses hidden sessions, and with rich shell integration, scrolls directly to the relevant command. With basic or no shell integration, the action still focuses the correct terminal tab.
  • Show Output opens the terminal's final output inline within the chat view. The output view expands automatically when a command exits with a non-zero code.

When npm i fails, the output is automatically expanded. The terminal is revealed with the Show Terminal inline action.

Discover hidden chat terminals (Experimental)

When setting(chat.tools.terminal.outputLocation):none, a new X hidden terminal(s) button appears in the terminal tabs view when there is at least one hidden chat terminal. It opens a quick pick that lists each chat terminal alongside its chat session so you can immediately focus the right process. The same picker is available from the terminal overflow menu under View Hidden Chat Terminals, and it disappears once all chat terminals are visible again.

The agent runs ls -la, which succeeds, so the output is collapsed. The hidden terminal action is taken from the tabs view and the terminal is selected, revealed, and scrolled to highlight the command.

Save conversation as prompt

You can now save your chat conversations as reusable prompts with the /savePrompt command. When you invoke /savePrompt in an active chat session, VS Code generates a prompt file containing a generalized prompt based on your conversation. The editor displays a blue button that lets you save this prompt to a valid location, either at the user or workspace level.

Screenshot of the Save prompt button in the editor.

This feature replaces the previous /save command and provides a more streamlined workflow for capturing and sharing useful conversation patterns. The generated prompts can be easily reused in future chat sessions or shared with your team. Learn more about custom prompt files.

Edit welcome prompts

You can now right-click on suggested prompts in the Chat welcome view to access additional actions. When you right-click a prompt (or press Shift+F10), a context menu appears with an Edit Prompt File option to open the corresponding prompt file directly in the editor.

Editing a prompt file works for prompts that have an associated file, including user-defined prompts and project-specific prompts configured through the chat.promptFilesRecommendations setting.

Screenshot of a context menu for a suggested prompt.

Learn more about custom prompt files.

Automatically open edited files

Setting: chat.openEditedFilesAutomatically

We changed the default behavior of the agent to no longer automatically open edited files in an editor. If you prefer the previous behavior, you can enable the setting accessibility.openChatEditedFiles.

Reasoning (Experimental)

Setting: chat.agent.thinkingStyle, chat.agent.thinking.collapsedTools

Last iteration, we added the chat.agent.thinkingStyle setting which enabled displaying thinking tokens in chat. This is now available in more models! As of this release, GPT-5-Codex, GPT-5, GPT-5 mini, and Gemini 2.5 Pro support this.

The chat.agent.thinkingStyle was adjusted to three more common styles, with fixedScrolling as the default to show the most recent chain of thoughts.

An additional setting, chat.agent.thinking.collapsedTools, adds tool calls into the collapsible thinking UI.

Screenshot showing reasoning tokens displayed in chat with interweaved tool cals and reasoning output. This is the UI with and for the respective thinking settings.

Inline chat v2 (Preview)

Setting: inlineChat.enableV2

We have ramped up our efforts to modernize inline chat. It's built to be

  • single prompt,
  • single file,
  • and for code changes only

This makes the overall experience much lighter and allows for a simplified UI. For tasks it cannot handle, you'll be automatically upgraded to the Chat view.

Chat view UX improvements

We tweaked some parts of the Chat view to make it feel more pleasant to use:

  • The action to create a new Chat is now a dropdown with options to create a chat session in the editor or in a new window
  • The tools and MCP server actions moved right next to the model picker
  • The configuration dropdown is cleaned up

Screenshot of the action to create a new chat dropdown menu.

It is now also possible to copy math source by right-clicking math expressions in the chat view.

MCP

MCP server access for your organization

Settings: chat.mcp.gallery.serviceUrl, chat.mcp.access

VS Code now supports MCP registry configured through GitHub organization policies. This enables organizations to set up a custom MCP registry and control which MCP servers can be installed and started.

When an MCP registry endpoint is configured in your organization's policies, VS Code will:

  • Provide browsing and installing of MCP servers from the configured registry
  • Restrict starting MCP servers to only those available in the registry when access restriction is enabled

When your organization has configured these policies, the chat.mcp.gallery.serviceUrl setting specifies the MCP registry endpoint URL, and the chat.mcp.access setting controls whether access is restricted to only the servers in that registry. These settings will be marked as "(Managed by organization)" in the Settings editor:

Screenshot showing MCP settings managed by organization policy, including the Gallery Service URL and Access control settings

To learn more about configuring MCP server access for your organization or enterprise, see Configure MCP server access.

Install MCP servers to workspace configuration

When installing an MCP server, you can now choose whether to install it globally or to the workspace configuration. Right-click on an MCP server in the extensions view and select Install (Workspace) from the context menu, or use the Install (Workspace) action directly in the MCP server editor. This adds the MCP server to the .vscode/mcp.json file in your current workspace, making it easier to share MCP servers with your team.

Screenshot showing the context menu for an MCP server with the Install (Workspace) option highlighted

Authentication: Client ID Metadata Document authentication flow

Authentication support for remote MCPs now supports the Client ID Metadata Document (CIMD) authentication flow, which is the future standard for OAuth in MCP. This flow enables a more secure and scaleable solution to authentication over Dynamic Client Registiration (DCR) because now authorization servers do not have to worry about issuing client IDs per-client.

When connecting to an MCP server that uses an authorization server that supports CIMD, VS Code will automatically use that flow over DCR.

For more information about CIMD, take a look at the resources on oauth.net.

Authentication: WWW-Authenticate scope step up

Authentication support for remote MCPs now supports dynamic scope escalation through the WWW-Authenticate header for remote MCP servers. This is called out in the OAuth 2.0 specification. This allows MCP servers to request additional permissions when needed, rather than requiring all scopes upfront. For example, connecting to a server might require a minimal set of scopes, but specific tool calls can request broader permissions only when necessary. This provides better security by following the principle of least privilege.

This is currently called out in the latest draft of the MCP specification which is expected to be finalized soon.

Accessibility

Speech timeout is disabled by default

The configuration accessibility.voice.speechTimeout has changed to be 0 by default. This means, a voice session no longer ends automatically after a certain delay (e.g. a Chat request would not be triggered automatically if you pause). We feel this is a better default experience, but you can always change back to the previous default (2500).

Chat input improvements

The chat input now announces the active agent and model in a clearer order so screen reader users hear the most relevant context first. The chat accessibility help also calls out that you can press Delete to remove attached context items, making attachment management fully keyboard-accessible.

Notebooks

Notebook search

Notebooks now supports searching across cells. Use key bindings (⌘G (Windows, Linux F3) and ⇧⌘G (Windows, Linux Shift+F3)) to navigate to the next and previous match, just like you would in the editor.

Source Control

Folding support in git commit messages

Settings: git.verboseCommit, git.useEditorAsCommitInput

When writing git commit messages in the editor, you can now fold sections of the commit message to keep things organized. To use this feature, enable the git.verboseCommit and git.useEditorAsCommitInput settings.

Screenshot showing folding nodes in the gutter and a partially collapsed commit message in the editor.

Graph incoming/outgoing changes

Settings: scm.graph.showIncomingChanges, scm.graph.showOutgoingChanges

This milestone, we are adding the capability to easily view incoming and outgoing changes in the Source Control Graph view. For active branches that have incoming or outgoing changes, the graph displays an "Incoming Changes" and "Outgoing Changes" node. Selecting each node displays the list of incoming or outgoing files.

Screenshot showing incoming and outgoing changes nodes in the Source Control Graph view.

You can hide this information from the Graph view by using the scm.graph.showIncomingChanges and scm.graph.showOutgoingChanges settings.

Graph compare references

We have added a new command to the Source Control Graph context menu, Compare with..., that enables you to compare a history item in the graph with an arbitrary branch or tag. This feature lets you view changes that are in the history item but not in the branch or tag.

In the context menu, there are shortcuts commands, Compare with Remote and Compare with Merge Base for comparing a history item with the remote branch and merge base respectively.

Repositories selection mode

Setting: scm.repositories.selectionMode

The Source Control Repositories view shows the list of opened repositories in the workspace and is used to control the repositories shown in the Source Control Changes view.

We are looking to expand the functionality of the Repositories view and in preparation for that, we are introducing a setting, scm.repositories.selectionMode, to control the selection mode in the Repositories view to either a single repository or multiple repositories.

Apart from the new functionality in the Repositories view, this also allows us to remove the repository picker in the Graph view's title and have a global repository picker across all source control views. You can toggle the selection mode using the setting, or from the "..." menu of the Repositories view.

Screenshot showing the Repositories view with single selection mode enabled and the context menu to toggle selection mode.

Repositories explorer (experimental)

Settings: scm.repositories.explorer, scm.repositories.selectionMode

We are looking at enhancing the Repositories view and showing additional information for each repository. To try out this experimental feature, set scm.repositories.selectionMode and scm.repositories.explorer.

In this first iteration, we have focused on branches and tags. You can create new branches, tags, view the list of branches and tags, and take various actions of each branch/tag (ex: checkout, etc.). In the upcoming milestone, we will add more information (ex: stashes, remotes, etc). Give this experimental feature a try and let us know what you think.

Screenshot showing the Repositories explorer with branches and tags for a single selected repository.

Testing

Navigate uncovered lines in test coverage

When reviewing test coverage, you can now easily navigate between uncovered lines using new navigation commands. Two commands are available in the editor toolbar when viewing coverage information:

  • Go to Next Uncovered Line - Jumps to the next line that is not covered by tests
  • Go to Previous Uncovered Line - Jumps to the previous line that is not covered by tests

These commands help you quickly identify coverage gaps and focus on areas that need additional test coverage, making it easier to improve the overall test quality of your codebase.

Terminal

Terminal IntelliSense

Terminal IntelliSense has been in the product as an experimental/preview feature for around 1.5 years! This release we're removing the preview tag and will be doing a staged roll out as the default to all users on stable.

When enabled, typing in the terminal will bring up IntelliSense similar to the editor for PowerShell, bash, zsh and fish:

Screenshot of typing "write" in PowerShell will bring up completions starting with the word write.

The completions have various sources, paths for example are all handled by core:

Some commands feature advanced specifications, like git which has the ability to pull in branch names:

If we learned anything when building this feature it's that no one size fits all, so there are many options to tweak the behavior to get what you're after:

If you are don't see the feature yet, make sure you have shell integration enabled and enable IntelliSense explicitly in settings via terminal.integrated.suggest.enabled.

Apart from overall polish, this is what is coming to the feature this release:

  • copilot and azd CLIs now have completions
  • The extension API is close to finalization
  • Git commit completions show the commit message

Screenshot of git commit completions showing branch names and their associated commit messages in the terminal suggest details view.

Consolidated shell integration timeout setting

We now have one unified configurable setting, terminal.integrated.shellIntegration.timeout, that controls how long VS Code waits for shell integration to become ready before executing commands in the terminal, including those triggered through the executeCommand API and by Copilot terminal tool.

chat.tools.terminal.shellIntegrationTimeout has been deprecated in favor of this consolidation.

Authentication

Manage extension account preferences discoverability

The Manage Extension Account Preferences command is now more discoverable. In addition to being available in the Command Palette and extension context menus, it now appears in the Account Menu alongside Manage Language Model Access. This makes it easier to find and configure which accounts extensions can access.

Screenshot of Manage Extension Account Preferences in the Account menu.

Last version of classic Microsoft authentication - use msal-no-broker if you experience issues

We will be removing the classic option for microsoft-authentication.implementation. This means that VS Code release 1.106 is the final version that has the classic option.

The microsoft-authentication.implementation setting has been around to let users opt-out of native brokered authentication for Microsoft accounts if they experienced issues. The values for this setting are:

  • msal - Use MSAL with brokered authentication when available (default)
  • msal-no-broker - Use MSAL without brokered authentication (introduced recently)
  • classic - Use the classic Microsoft authentication flow without MSAL

We will remove the classic option since it's usage is very low and most issues with the msal option are due to the brokering, which is remedied with msal-no-broker.

Device code flow for Microsoft authentication

Microsoft authentication now supports the device code flow in non-brokered scenarios, particularly useful for remote development environments. When other authentication methods fail, VS Code automatically falls back to device code flow, which displays a code that you can enter on another device to complete authentication.

Manage accounts command

Manage your authentication accounts directly from the Command Palette using the Accounts: Manage Accounts command. This command provides access to account management features when the Account menu is hidden or not easily accessible.

Screenshot of the Manage Accounts menu.

When you run the Manage Accounts command, you'll see a quick pick menu listing all your active accounts. You can select an account to view available actions, including:

  • Manage Trusted Extensions - Control which extensions can access the selected account
  • Manage Trusted MCP Servers - Manage MCP server access permissions for accounts that support this capability
  • Sign Out - Sign out of the account

Languages

Python

Python Environments Extension: Support for python.poetryPath setting

The Python Environments Extension now respects the existing python.poetryPath user setting. This allows you to specify which Poetry executable to use. The provided path will be searched for and selected when managing Poetry environments.

Python Environments Extension: Improved venv creation: dev-requirements.txt detection

When creating a new virtual environment, the extension now detects both requirements.txt and dev-requirements.txt files and installs dependencies automatically.

Add Copilot Hover Summaries as docstring

You can now add your AI-generated documentation directly into your code as a docstring using the new Add as docstring command in Copilot Hover Summaries. When you generate a summary for a function or class, navigate to the symbol definition and hover over it to access the Add as docstring command, which inserts the summary below your cursor formatted as a proper docstring.

This streamlines the process of documenting your code, allowing you to quickly enhance readability and maintainability without retyping.

Localized Copilot Hover Summaries

GitHub Copilot Hover Summaries inside Pylance now respect your display language within VS Code. When you invoke an AI-generated summary, you'll get strings in the language you've set for your editor, making it easier to understand the generated documentation.

Screenshot of a Copilot Hover Summary generated in Portuguese.

Convert wildcard imports Code Action

Wildcard imports (from module import *) are often discouraged in Python because they can clutter your namespace and make it unclear where names come from, reducing code clarity and maintainability. Pylance now helps you clean up modules that still rely on from module import * via a new Code Action. It replaces the wildcard with the explicit symbols, preserving aliases and keeping the import to a single statement. To try it out, you can click on the line with the wildcard import and press Ctrl+. (or Cmd+. on macOS) to select the Convert to explicit imports Code Action.

Screenshot of the Convert wildcard imports Code Action.

dotenv

There is built in basic support for dotenv files (.env), which are commonly used to define environment variables for applications.

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:

  • AI-generated PR descriptions (via githubPullRequests.pullRequestDescription) will respect the repository PR template if there is one.
  • Drafts in the Pull Requests view now render in italics instead of having a [DRAFT] prefix.
  • Pull requests can be opened from from a url, for example: vscode-insiders://github.vscode-pull-request-github/checkout-pull-request?uri=https://github.com/microsoft/vscode-css-languageservice/pull/460

Review the changelog for the 0.122.0 release of the extension to learn about everything in the release.

Preview Features

Language Models editor

A new Language Models editor provides a centralized place to view and manage all available language models for GitHub Copilot Chat. You can open it from the chat model picker or via the command Chat: Manage Language Models.

Note: This feature is only available in VS Code Insiders.

Screenshot showing the Language Models editor with a list of models organized by provider.

The editor displays:

  • All available models organized by provider
  • Model capabilities (tools, vision, agent)
  • Context size and multiplier information
  • Model visibility status

You can search and filter models using:

  • Text search with highlighting
  • Provider filter: @provider:"OpenAI"
  • Capability filters: @capability:tools, @capability:vision, @capability:agent
  • Visibility filter: @visible:true/false

Hover over model names or context sizes to see detailed information including model ID, version, status, and token breakdown.

Manage model visibility

Control which models appear in the chat model picker by toggling their visibility with the eye icon next to each model. When a model is visible, it appears in the model picker dropdown when you're using GitHub Copilot Chat, making it available for selection. Hidden models remain in the Language Models editor but won't appear in the model picker, helping you keep your model selection focused on the ones you use most frequently.

Screenshot showing the eye icon to toggle model visibility with a tooltip displaying "Show in the chat model picker"

This is particularly useful when you have access to many models and want to streamline your workflow by showing only your preferred models in the picker.

Add models from installed providers

Use the Add Models... button to configure and add models from language model providers you've already installed. When you select this button, you'll see a dropdown list of all installed model providers, such as Copilot, Anthropic, Azure, Google, Groq, Ollama, OpenAI, and others. Select a provider from the list to configure it and start using its models in GitHub Copilot Chat.

Screenshot showing the Add Models dropdown with a list of installed language model providers including Copilot, Anthropic, Azure, Google, and more

This makes it easy to activate additional model providers you've installed without needing to navigate away from the Language Models editor. Access provider management by selecting the gear icon on provider rows.

Extension Authoring

ID token in authentication sessions

The AuthenticationSession interface now includes an optional idToken property. This allows authentication providers to return ID tokens in addition to access tokens, which is particularly useful for scenarios that require user identity information. The Microsoft authentication provider returns this field, while other providers like GitHub may not.

ID tokens contain claims about the authenticated user and are signed by the identity provider, making them useful for verifying user identity. For more information about the difference between ID tokens and access tokens, see https://oauth.net/id-tokens-vs-access-tokens/.

export interface AuthenticationSession {
  /**
   * The ID token.
   */
  readonly idToken?: string;
}

Git extension getRepositoryWorkspace API

The build in Git extension offers new API for getting a folder that's known to be associated with a git repository remote. This works by caching a repository-remote to folder mapping when the user opens a folder with a git remote.

View containers in Secondary Side Bar

Extension authors can now register view containers in the Secondary Side Bar by using the new secondarySidebar contribution point. This lets extensions place their custom views alongside built-in views like Chat in the Secondary Side Bar and provide a better integration with VS Code's dual side bar layout.

{
  "contributes": {
    "viewsContainers": {
      "secondarySidebar": [
        {
          "id": "myExtensionViews",
          "title": "My Extension",
          "icon": "$(extensions)"
        }
      ]
    },
    "views": {
      "myExtensionViews": [
        {
          "id": "myCustomView",
          "name": "Custom View",
          "when": "true"
        }
      ]
    }
  }
}

Proposed APIs

Quick Pick and Quick Input improvements

The Quick Pick and Quick Input APIs include several new capabilities that give extension developers more flexibility in creating interactive user interfaces.

Proposed API: Toggle button support

Extensions can add toggle buttons to Quick Pick and Quick Input interfaces through the toggles property on QuickInput. This enables scenarios like a password visibility toggle in the input box area, allowing users to interact with controls without leaving the quick pick interface.

Your comments and feedback on this API proposal are appreciated (please refer to the GitHub issue).

export enum QuickInputButtonLocation {
  ...

  /**
   * The button is rendered at the far end inside the input box.
   */
  Input = 3
}

export interface QuickInputButton {
  ...

  /**
   * When present, indicates that the button is a toggle button that can be checked or unchecked.
   *
   * **Note:** This property is currently only applicable to buttons with {@link QuickInputButtonLocation.Input} location.
   * It must be set for such buttons, and the state will be updated when the button is toggled.
   * It cannot be set for buttons with other location values.
   */
  readonly toggle?: { checked: boolean };
}

Proposed API: Prompt support for Quick Pick

Quick Pick supports a prompt property, similar to the one available in Input Box. The prompt displays persistent text beneath the input box that remains visible while users type, providing helpful guidance or instructions that doesn't disappear when the user starts entering text.

Your comments and feedback on this API proposal are appreciated (please refer to the GitHub issue).

export interface QuickPick<T extends QuickPickItem> extends QuickInput {
  /**
   * Optional text that provides instructions or context to the user.
   *
   * The prompt is displayed below the input box and above the list of items.
   */
  prompt: string | undefined;
}

export interface QuickPickOptions {
  /**
   * Optional text that provides instructions or context to the user.
   *
   * The prompt is displayed below the input box and above the list of items.
   */
  prompt?: string;
}

Proposed API: File icons for Quick Pick items

Quick Pick items can display file-type-specific icons through the resourceUri property on QuickPickItem. When you provide a resource URI, VS Code automatically derives the appropriate label, description, and icon based on the resource type, matching your current theme's file icon set. This is particularly useful when building file or folder selection interfaces, as users can quickly identify items by their familiar file type icons.

Your comments and feedback on this API proposal are appreciated (please refer to the GitHub issue).

export interface QuickPickItem {
  /**
   * A {@link Uri} representing the resource associated with this item.
   *
   * When set, this property is used to automatically derive several item properties if they are not explicitly provided:
   * - **Label**: Derived from the resource's file name when {@link QuickPickItem.label label} is not provided or is empty.
   * - **Description**: Derived from the resource's path when {@link QuickPickItem.description description} is not provided or is empty.
   * - **Icon**: Derived from the current file icon theme when {@link QuickPickItem.iconPath iconPath} is set to
   *   {@link ThemeIcon.File} or {@link ThemeIcon.Folder}.
   */
  resourceUri?: Uri;
}

GitHub-style alerts in MarkdownStrings (#209652)

We have added support for rendering GitHub-style alert syntax in MarkdownString by setting a new property supportAlertSyntax.

const markdown = new vscode.MarkdownString();
markdown.supportAlertSyntax = true;
markdown.value = `
> [!NOTE]
> Useful information that users should know, even when skimming content.

> [!TIP]
> Helpful advice for doing things better or more easily.

> [!IMPORTANT]
> Key information users need to know to achieve their goal.

> [!WARNING]
> Urgent info that needs immediate user attention to avoid problems.

> [!CAUTION]
> Advises about risks or negative outcomes of certain actions.
`;

This enables extensions to render alerts in various places in the UI, such as comments:

Screenshot showing GitHub-style alerts displayed in a comment thread showing each alert type with their respective icons and styling.

MarkdownString support in TreeItem labels (#115365)

Extension authors can now use MarkdownString in tree view item labels, enabling a subset of Markdown syntax including codicons and text formatting. This allows extensions to create more visually rich tree views.

// Codicons
const itemWithIcon = new vscode.TreeItem({
  label: new vscode.MarkdownString('$(star) Starred item', true)
});

// Text formatting (must surround the entire string)
const italicItem = new vscode.TreeItem({
  label: new vscode.MarkdownString('_Italic item_')
});

// Formatting and codicons can be combined
const combined = new vscode.TreeItem({
  label: new vscode.MarkdownString('_~~**$(check) Done $(star)**~~_', true)
});

The above items render as: Screenshot of a tree view showing three items: a starred item with an icon, an italic item, and a combined item with check and star icons plus bold, italic, and strikethrough formatting.

Engineering

Exploration of automated UX PR testing

We've introduced a new automation workflow that helps reviewers understand UI changes in pull requests without manually checking out and running the code. By adding the ~copilot-video-please label to a pull request with UI changes, an automated process kicks off that:

  • Builds VS Code from the PR branch
  • Uses GitHub Copilot CLI to interact with the changes and record a video along the way - leveraging playwright-mcp
  • Generates a Playwright trace for detailed inspection
  • Posts the results as a comment on the PR

While it's still early, this workflow can reduce the manual effort required for code review, especially for small UI changes. The videos and traces help reviewers quickly verify that changes work as expected. Currently, the videos are only accessible to team members.

For more details about this automation, see https://github.com/microsoft/vscode/issues/272529.

macOS 11.0 support has ended

VS Code 1.106 is the last release that supports macOS 11.0 (macOS Big Sur). Refer to our FAQ for additional information.

Notable fixes

  • vscode#258236 - Add setting for extensions request timeout used when installing extensions
  • vscode#272945 - Tasks do not trigger onDidStartTerminalShellExecution
  • vscode#273372 - /** is automatically closed with */ in .gitignore files
  • vscode#243584 - First input gets ignored on pwsh/conpty
  • vscode#271952 - Copilot 'configure instructions' quickpick doesn't show workspace-level agent instruction files (copilot-instructions.md, AGENTS.md)
  • vscode#274631 - Network: Load intermediate certification authorities on Windows

Thank you

Issue tracking

Contributions to our issue tracking:

Pull Requests

Contributions to vscode:

Contributions to vscode-copilot-chat:

Contributions to vscode-html-languageservice:

Contributions to vscode-json-languageservice:

Contributions to vscode-languageserver-node:

Contributions to vscode-pull-request-github:

Contributions to vscode-test-cli:

Contributions to debug-adapter-protocol:

Contributions to language-server-protocol:

Contributions to monaco-editor:

Contributions to node-pty:

Contributions to python-environment-tools:

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.