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

November 2025 (version 1.107)

Release date: December 10, 2025

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

VS Code 1.107 introduces multi-agent orchestration - use GitHub Copilot and custom agents together to accelerate and parallelize development.

  • Agent HQ gives you one place to manage all your agents, letting Copilot and custom agents collaborate across tasks.
  • Background agents run in isolated workspaces to not interfere with your active work, and enabling multiple background tasks at once.
  • Delegate work across local, background, or cloud agents to keep your workflow moving without interruptions.

VS Code November 2025 release image.


Watch our VS Code 1.107 release highlights video to hear about these features from our engineers!

Happy Coding!


Read these release notes online at Updates on code.visualstudio.com.
Insiders: Download the nightly Insiders build to try the latest updates as soon as they're available.

Agents

  • Manage your agents from chat (Show more).
  • Share agents across your organization (Show more).
  • Keep agents active while chat is closed (Show more).
  • Move agent sessions from local to cloud (Show more).
  • Run agents in dedicated Git worktrees (Show more).
  • Attach context to background agents (Show more).
  • Customize background agents (Show more).
  • Reuse custom agents across environments (Show more).
  • Run custom subagents (Show more).
  • Reuse Claude skills (Show more).

Integrating agent sessions and chat

Setting: chat.viewSessions.enabled

Agents are key to autonomously performing coding tasks on your behalf. The chat interface is the main way to interact with agents, regardless of where they are running: locally in VS Code, in the background using a CLI, in the cloud, or from 3rd party extensions. Learn more about using agents in VS Code in our documentation.

This iteration, we integrated the agent sessions into the Chat view to give you a unified experience when working with agents. At a glance, you can see the session's status, progress, and file change statistics. You can archive or unarchive sessions to keep the sessions list manageable.

If you are working in a workspace, the session list only shows sessions related to the current workspace. If you are in an empty window, all sessions across workspaces are shown.

When you select a session from the list, it opens the session in the Chat view in the Side Bar, allowing you to see the full conversation history. If you prefer, you can also open a session as an editor tab or in a new window. Right-click a session to see the context menu with these options.

Screenshot showing the context menu of a session in the sessions list.

You can disable the sessions list in the Chat view by configuring chat.viewSessions.enabled.

As a consequence of this change, we're disabling the standalone Agent Sessions view by default. If you prefer to keep using the standalone view, you can re-enable it via chat.agentSessionsViewLocation. In a future release, we plan to remove the standalone view entirely.

Compact view

When the Chat view is narrow, the list of sessions is shown inside the Chat view when you start a new chat session. By default, the list shows the three most recent sessions that are not archived.

Screenshot showing the recent sessions in the Chat view.

Select Show All Sessions to view the full list of sessions with options to search and filter.

Screenshot showing all sessions in the Chat view.

You can use the action to toggle the agent sessions sidebar for a wider experience of all sessions.

Side-by-side view

Once the Chat view is wide enough (for example, when you maximize it), the list of agent sessions is automatically shown side-by-side with the Chat view. This view lets you quickly navigate between sessions without losing context. You can also manually toggle this side-by-side view using the corresponding control.

Screenshot showing all sessions side-by-side with the Chat view.

To limit the sessions list, you can filter sessions by provider or state. VS Code persists this filter.

Orientation setting

Setting: chat.viewSessions.orientation

By default, the sessions list appears side-by-side with the Chat view when it's wide enough or if you manually toggle the sessions list. You can change this behavior with the chat.viewSessions.orientation setting.

  • auto (default): show the sessions side-by-side if the width allows it, otherwise show them above empty chats
  • stacked: always show the sessions above empty chats
  • sideBySide: show the session list side-by-side if the width allows it, otherwise hide the sessions list

Local agent sessions remain active when closed

Previously, when you closed a local chat session, a running agent request was cancelled. This limited the usefulness of local agents for long-running tasks or for running multiple tasks simultaneously.

Now, the local agent continues running in the background, even when not open in a chat editor or the Chat view. You are able to see the status of the running agent in the sessions list and can switch back to the session at any time to see the detailed progress.

Learn more about using local agent in chat.

Continue tasks in background or cloud agents

Local agents are great for interactive sessions inside VS Code where you can go back and forth with the agent. This can be useful for brainstorming, performing exploratory tasks, or to work out an implementation plan. Once you have a clear plan, you can then hand the task off to a background or cloud agent to execute it autonomously.

This iteration, we have improved the experience to continue a local chat with a background or cloud agent. Across the UI, you can now continue a task seamlessly using the new Continue in option.

When you continue a local chat to background or cloud agent, the current chat context is passed along and the original session is archived after handoff.

  • Chat view:

    Screenshot showing the 'Continue in' button in the Chat view.

  • Plan agent:

    Screenshot showing the 'Start implementation' button when using the Plan agent.

  • Untitled prompt file:

    Screenshot showing the 'Continue in' button in an untitled prompt file.

Isolate background agents with Git worktrees

Background agents (previously called CLI agents) are designed to run autonomously in the background, allowing you to offload tasks while you focus on other work. Running multiple background agents simultaneously can lead to conflicts if they modify the same files in your workspace.

This iteration, we enhanced the isolation of background agents by introducing support for Git worktrees. When you create a new background agent, you can choose to either run it on the current workspace or to run it in a dedicated Git worktree.

Screenshot showing the Git Worktree dropdown when creating a background agent.

When you run a background agent in a worktree, the agent automatically creates a new Git worktree for the session, isolating its changes in a separate folder. This lets you run multiple background agents simultaneously without conflicts.

You can easily review and merge the changes made by the background agent in the worktree back into your main workspace when the agent completes its task. We've also added a new action to directly apply the changes from a worktree directly into your workspace.

Screenshot of a background agent, showing the file changes that occurred in the worktree.

Learn more about using background agents in VS Code.

Adding context to background agents

Background agents now support multiple context attachment types. You can attach selections, problems, symbols, search results, git commits, and more to any prompt. This makes it possible to build richer, more precise prompts, unlocking more complex and flexible workflows. For example, attach a reported problem and ask the agent to fix it without manually specifying file paths and line numbers.

Screenshot of a background agent session with a symbol and error attached as context.

Share custom agents across your GitHub organization (Experimental)

Setting: github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents

Previously, you could only define custom agents at a workspace or user level. If you wanted to share custom agents across your organization, you had to manually distribute the agent files to each user.

In this release, you can now define custom agents at the organization level for your GitHub account. This experimental feature enables you to use organization-specific agents alongside your personal agents in chat.

To enable this feature, set github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents to true. Once enabled, custom agents created by your organization appear in the Agents dropdown in VS Code.

To learn more about creating custom agents for your organization, see Create custom agents in the GitHub documentation.

Use custom agents with background agents (Experimental)

Setting: github.copilot.chat.cli.customAgents.enabled

You can now bring your own custom agents into Background Agents. Once enabled, custom agents defined in your .github/agents folder will appear in your agent list, allowing you to leverage agents tailored to your workflows and requirements.

This experimental functionality can be enabled with the github.copilot.chat.cli.customAgents.enabled setting.

Screenshot showing a background agent session with a custom Planner agent in the Agents dropdown list.

Learn more about defining custom agents in our documentation.

Agent tooling reorganization

We've reorganized the agent tooling structure to enable better compatibility with GitHub custom agents. This lets you more easily reuse custom agents across VS Code and GitHub environments without requiring separate configurations.

As part of this change, we've renamed certain existing tool references and the toolsets they belong to. Existing tool references in your agent files will continue to work, but you'll see a Code Action for renaming them to the latest recommended format. This ensures that your agent configurations follow the current best practices and maintain compatibility across platforms.

Run agents as subagents (Experimental)

Setting: chat.customAgentInSubagent.enabled

When an agent needs to solve a complex issue, it can delegate tasks to subagents. Subagents work independently from the main chat session and have their own context window. This helps the main conversation to stay focused on the high-level objective and helps to manage context window limitations.

With this release, you can customize subagents via custom agents. Custom agents let you define specialized personas for the AI, tailoring their behavior to specific tasks or domains. For example, a code reviewer agent focuses on reviewing code rather than make code changes.

To use custom agents as subagents, follow these steps:

  1. Enable chat.customAgentInSubagent.enabled

  2. Create a custom agent with the Chat: New Custom Agent command, if you don't have one yet.

  3. In chat, ask the model "what subagents can you use?" to see the list of available subagents. Your custom agent should appear in the list.

  4. Enter a prompt that meets the requirements for your custom agent. The language model uses the custom agent description and arguments to determine if it should be used for your request.

    Screenshot of a chat conversation that uses a custom agent as subagent.

To prevent a custom agent from being used as a subagent, set the metadata property infer to false in the *.agent.md file.

Learn more about using subagents in chat.

Reuse your Claude skills (Experimental)

Setting: chat.useClaudeSkills

Skills were introduced by Claude Code and are capabilities that an agent can load on-demand. Each skill comes with a short description that advertizes the skill. If useful, the agent can decide to read the full skill instructions. Skill instructions can come with supporting files like scripts and templates. Once loaded, skills instructions and supporting files are part of the context of the main conversation.

VS Code can now reuse your existing skills. Enable the chat.useClaudeSkills setting to allow agents to discover and use your skills.

Screenshot that shows reusing Claude skills in chat in VS Code.

VS Code supports personal skills found at ~/.claude/skills/skill-name/SKILL.md and project skills found in workspace folders at ${workspaceFolder}.claude/skills/skill-name/SKILL.md.

Check that the SKILL.md file has a description attribute in the header that advertizes the skill. Note that the allowed-tools attribute is not supported in VS Code.

In agent mode, make sure you have the read-file tool enabled and ask "What skills do you have" to find out if skills are found. Next, make a request that can be answered with a skill. If the agent doesn't use the skill, improve the skill description or nudge the model to use skills.

Chat

  • Inline chat is optimized for code edits (Show more).
  • Manage your chat models (Show more).
  • Review external web content (Show more).
  • Fetch dynamic web content (Show more).
  • Search ignored files (Show more).
  • Access terminal output in chat (Show more).
  • Automatically approve terminal commands for your session (Show more).
  • More keyboard shortcuts are available (Show more).
  • Use Entra ID for Azure-hosted models (Show more).
  • Use chat more efficiently (Show more).
  • View diffs for edits to sensitive files (Show more).
  • Hide chat tool calls for reasoning models (Show more).

Inline chat UX

Setting: inlineChat.enableV2

We continue to improve the inline chat experience to align it with the other chat experiences in VS Code and to optimize it for quick, single-file code changes.

Previously, you could also use inline chat for general questions and discussions. Now, inline chat is optimized for code changes within the current file. For tasks that inline chat cannot handle, you are automatically upgraded to the Chat view where your prompt is being replayed, using the same model and the same context

The inlineChat.enableV2 setting (preview) now only controls how the extension handles your prompt. This is still under development but can be tried with confidence.

Language Models editor

Chat in VS Code supports multiple language models, either provided by GitHub Copilot, third-party extensions, or via bring your own key (BYOK) providers. Managing all these models can be challenging, especially when you have access to many models across different providers. Learn more about using language models in VS Code.

The Language Models editor provides a centralized place to view and manage all available language models for chat in VS Code. You can open it from the model picker in chat or via the Command Palette with Chat: Manage Language Models.

The editor lists all models available to you, showing key information such as the model capabilities, context size, billing details, and visibility status. By default, models are grouped by provider, but you can also group them by visibility.

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

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

Manage model visibility

As more models are available to you, the model picker can become overwhelming and difficult to navigate. In the Language Models editor, you can toggle the visibility of each model to control which models appear in the model picker. Hover over a model and select the eye icon to toggle its visibility.

Add models from installed providers

From the Language Models editor, you can add more models with Add Models.... This shows a dropdown list of all installed model providers. Select a provider to configure it and add its models to chat in VS Code.

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.

URL and domain auto approval

This iteration, we enhanced the security and user experience of auto-approving URLs for the fetch tool. When the model decides to fetch content from a URL that you did not explicitly ask for, you'll see the new two-step approval experience:

  • Approve the initial request to fetch the URL

    This step ensures that you trust the domain being contacted and can prevent sensitive data to be sent to untrusted sites.

    Screenshot showing a confirmation to approve the initial fetch request.

    You have options for one-time approval or automatically approving future requests to the specific URL or domain.

    The pre-approval respects the "Trusted Domains" feature. If a domain is listed there, you are automatically approved to make requests to that domain and are deferred to the response reviewing step.

  • Approve to use the fetched content in chat and follow-up tool calls

    This step ensures that you review the fetched content before it is added to the chat or passed to other tools, preventing potential prompt injection attacks.

    For example, you might approve a request to fetch content from a well-known site, like GitHub.com. But because the content, such as issue description or comments, is user-generated, it could contain harmful content that might manipulate the model's behavior.

Learn more about URL and domain approval in VS Code chat.

More robust fetch tool

The #fetch agent tool now handles dynamic web content more effectively. It can retrieve dynamic content, in addition to static HTML. Websites that rely on JavaScript to load their content, such as Single-Page Applications (SPAs), modern documentation sites, or issue tracking systems like Jira, no longer return incomplete or empty results.

The fetch tool waits for JavaScript to execute and content to load before retrieving the page, ensuring that dynamically-rendered content is captured. This improvement makes the tool significantly more useful in real-life scenarios.

When you use #fetch followed by a URL, the model accesses the actual content you'd see in the browser, not just the initial HTML skeleton. This means more accurate and complete information when asking questions about web pages or requesting the model to analyze online content.

Text Search tool can search ignored files

The #textSearch tool now supports searching in ignored files/folders specified by files.exclude or search.exclude settings or .gitignore files, such as the node_modules folder. It also returns hints to the agent about the ignored files/folders when there are no results, allowing agents to turn around and enable searching in those ignored files/folders.

Rich terminal output in chat

Using Toggle Output on a Run in Terminal response now renders output in a full, read-only xterm.js terminal inside chat. A nice benefit of this approach is that VS Code preserves captured output even after the backing terminal has exited, so you can reopen previous runs at any time and see the terminal output as it was when the command ran.

The chat terminal now adopts the integrated terminal's color theme for improved ANSI color contrast. Screen reader users can open the accessible view ⌥F2 (Windows Alt+F2, Linux Shift+Alt+F2) when the output has focus, enabling easy review and navigation.

Learn more about using terminal commands in chat.

Command status details in chat terminals

Chat terminal messages now display command start time, duration, and exit code on hover of the command decoration.

Screenshot of the terminal showing npm install candy is run by the agent and the command decoration hover displays command execution time and status.

Allow all terminal commands in this session

To optimize your chat experience, while maintaining security and control, the terminal tool has a new auto approve option to allow all future commands for the session. When you start a new session, terminal commands will follow the existing approval configuration.

Screenshot that shows the Allow All Commands in this Session option when approving a terminal command in chat.

Keyboard shortcuts for chat terminal actions

You can now focus the most recent chat terminal ⇧⌥⌘T (Windows, Linux Ctrl+Shift+Alt+T) or toggle its expansion state ⇧⌥⌘O (Windows, Linux Ctrl+Shift+Alt+O) via dedicated keyboard shortcuts.

Keyboard shortcuts for custom agents

Each custom agent now has a separate action in the command list for them and you can bind keyboard shortcuts to them individually. For example, if you define a "Code Reviewer" custom agent, there will be a Chat: Open Chat (Code Reviewer Agent) command in the Command Palette to bind a keyboard shortcut to.

Screenshot of custom agent commands in the Command Palette.

Azure model provider: Entra ID as the default authentication

Setting: github.copilot.chat.azureAuthType

By default, the Azure model provider now uses Entra ID authentication when connecting to Bring-Your-Own-Key (BYOK) models, providing improved security and a more streamlined sign-in experience.

If you prefer to authenticate using an API key, set github.copilot.chat.azureAuthType to apiKey instead of entraId (default).

Chat view appearance improvements

We've made several improvements to the Chat view's appearance to enhance readability and usability:

  • Chat title:

    When you open a chat, a new title control appears to the top showing you the title of the chat as well as giving you a quick way to get back to an empty chat. Configure this behavior via the chat.viewTitle.enabled setting.

  • Welcome banner:

    If you prefer a more minimal experience when opening a new chat, the new setting chat.viewWelcome.enabled lets you hide the icon and welcome text.

    Screenshot of empty chat view with the icon and welcome text hidden.

  • Restore previous chat session:

    When you open chat after restarting or opening a different workspace, the previous session is now restored by default. You can change this behavior via the chat.viewRestorePreviousSession setting and choose to always start with an empty chat.

Diffs for edits to sensitive files

When chat attempts to edit sensitive files, such as the settings.json or package.json, you get a notification and are asked to approve the changes before they are applied. You can configure which files are considered sensitive via the chat.tools.edits.autoApprove setting.

Previously, you would see the raw edit that the model proposed, which could be difficult to understand. Now, we show you a diff of the proposed changes, making it easier to review and approve the edits.

Screenshot showing a diff of proposed changes to in chat.

Learn more about editing sensitive files in chat.

Collapsible reasoning and tools output (Experimental)

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

With language model reasoning and agent tools output, a chat conversation can quickly become long and difficult to follow. Last iteration, we already worked on improving how we display thinking tokens in chat with the chat.agent.thinkingStyle setting.

This iteration, we're further optimizing the chat experience by introducing collapsible chat sections for non-reasoning chat output, such as tool calls. By default, successive tool calls are now collapsed to reduce visual noise.

Collapsible items (most tools and reasoning text) will be summarized and an AI-generated title will be given to each collapsible section.

Screenshot showing multiple tool calls collapsed in a collapsible section.

MCP

  • We added support for the latest MCP specification (Show more).
  • Use the GitHub remote MCP server without extra setup (Show more).

Support for the latest MCP specification

VS Code supports the latest revision of the MCP specification, 2025-11-25. This includes, among other things:

These improvements come in addition to the 2025-11-25 draft features VS Code already supported, such as WWW-Authenticate scope consent, the Client ID Metadata Document authentication flow, and icons for tools, resources, and servers. You can view the changelog for the 2025-11-25 draft on the MCP website.

Learn more about using MCP servers in VS Code.

GitHub MCP Server provided by GitHub Copilot Chat (Preview)

Setting: github.copilot.chat.githubMcpServer.enabled

The GitHub remote MCP Server is now provided as a built-in MCP server in the GitHub Copilot Chat extension, providing seamless integration with GitHub repositories and services. This integration offers several benefits:

  • Alignment with other Copilot agent harnesses like Copilot CLI and Copilot Cloud Agent that already use the GitHub MCP Server
  • Reuse of existing GitHub authentication state, eliminating additional authentication prompts
  • Transparent support for different GitHub MCP endpoints including GHE.com

To enable the GitHub MCP Server, set the github.copilot.chat.githubMcpServer.enabled setting to true. Once enabled, the server automatically appears in the tool picker when using agents. This enables you to ask questions about GitHub issues, pull requests, and other repository information without additional configuration and setup.

The GitHub MCP Server supports customization through several settings:

Note: This feature is currently in Preview and requires explicit opt-in through the setting mentioned above. We are planning to enable it by default in a future release in a way that makes it available when wanted, but not intrusive when not needed.

Accessibility

Keyboard approval for chat confirmations

When an agent prompts for confirmation, you can now approve via keyboard using ⌘Enter (Windows, Linux Ctrl+Enter).

Editor Experience

  • More easily identify open projects (Show more).
  • Swipe to navigate on macOS (Show more).
  • Choose when to view hover popups (Show more).

More support to indicate opened windows in pickers

We added an indicator to the Open Recent picker for when a workspace is already open in a VS Code window.

Screenshot of recently opened workspaces.

The currently active window is indicated slightly differently from other opened windows to make that distinction clearer. Entries that are not opened in any window have no icon.

The indicator of which window is active has also been applied to the window picker.

macOS: Mouse swipe to navigate

Setting: workbench.editor.swipeToNavigate

On macOS you can now navigate between editors using 3-finger swipe gesture with the trackpad. Swiping left or right navigates across recently used editors in any editor group. Enable this with the workbench.editor.swipeToNavigate setting.

Note: We currently only support 3-finger swipe gesture. Make sure that your trackpad settings for swiping are configured like the following to make this work:

  • Swipe between pages: Scroll left or right with three fingers.
  • Swipe between full-screen apps: Swipe left or right with four fingers.

On demand editor hover popups

Setting: editor.hover.enabled

You can now disable automatic hover popups in the editor, while retaining the ability to trigger hover information on-demand using a keyboard modifier. The editor.hover.enabled setting now supports three values: on, off, and onKeyboardModifier.

When set to onKeyboardModifier, hover information only appears when you hold the opposite modifier key from your editor.multiCursorModifier setting while hovering over code. This reduces visual distractions during text selection while preserving quick access to contextual information when needed.

For example, if your editor.multiCursorModifier is set to ctrlCmd, hover appears when you hold Alt while hovering. If set to alt, hover appears when you hold Ctrl (or Cmd on macOS).

Code Editing

  • TypeScript offers rename suggestions (Show more).
  • Use a new model for next edit suggestions (Show more).
  • Preview next edit suggestions outside your viewport (Show more).

Rename suggestions for TypeScript

Rename suggestions predict when a symbol rename should happen instead of a regular text suggestion. When predicted, an additional indicator is shown together with the normal textual edit. You can then apply the symbol rename by using Shift+Tab.

In the following video, property a is renamed to width. The rename suggestion then suggests to rename b to height, as well as renaming the two parameters a and b accordingly. Next rename suggestion works best when it predicts related renames to other symbols.

Note: this feature is currently rolled out to our user base using an experiment and is only available for TypeScript for now. Support for other programming languages is planned.

New model for next edit suggestions

We have released a new model for next edit suggestions that is smarter and more in-tune with your latest edits. It delivers significantly better acceptance and dismissal performance. Learn more about the model and its development in our GitHub blog post.

Preview next edit suggestions outside the viewport

When you receive a next edit suggestion that is outside the current viewport, it can be difficult to know what the suggestion is without scrolling away from your current position. We improved this experience by rendering a preview of the next edit suggestion where your cursor is currently located. This helps reduce the impact on your flow when reviewing suggestions.

Note: Our current language model focuses on next edit suggestions close to the cursor, so you might not often see suggestions outside the viewport. However, we are actively working on models which can give you suggestions much further away!

Learn more about inline suggestions in VS Code.

Source Control

Stashes in the Source Control Repositories view (Experimental)

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

This milestone, we continued to expand the list of repository artifacts shown in the Source Control Repositories view by adding a Stashes node. Under this node, you can see the complete list of stashes, view, apply, and pop each stash. The context menu also contains an action to drop each stash.

Screenshot of the Source Control Repositories view showing the Stashes node and its context menu.

You can enable the experimental repository explorer by setting the scm.repositories.selectionMode and scm.repositories.explorer settings. Please give it a try and let us know what other repository artifacts you would like to see in the repositories explorer.

Learn more about using source control in VS Code.

Debugging

Attach variables to chat

You can now attach variables, scopes, and expressions to your chat context in VS Code. You can do this by right clicking on data in the Variables and Watch views, or by using the Add Context button in chat.

Terminal

Terminal suggest rolled out to stable

Terminal Suggest is now enabled for stable users, offering inline completions and contextual hints while you type shell commands. Suggestions now group related argument values together, so option flags and their parameters stay organized in the list.

Authentication

Cross-platform native broker support for Microsoft Authentication

Setting: microsoft-authentication.implementation

This milestone, we adopted the latest MSAL libraries, enabling you to sign in through a native experience on:

  • Intel Macs
  • Linux x64 (just certain distros that are Debian-based)

Screenshot of a native broker dialog window asking to sign into VS Code.

This is in addition to the existing support for:

  • Windows x64
  • macOS M-series (ARM)

macOS and Linux support requires your machine to be Intune enrolled and be opted in to using the native broker.

This enables nice single sign-on flows and is the recommended way of acquiring a Microsoft authentication session. The MSAL team will enable this up for the remaining platforms (Windows ARM, Linux ARM and additional distros) over time, so stay tuned!

NOTE: If you have trouble authenticating via the broker, you can change the microsoft-authentication.implementation to msal-no-broker, which will use your browser to authenticate instead.

classic Microsoft authentication no longer available

As mentioned last month, we have removed the classic option for microsoft-authentication.implementation due to low usage and it not being recommended by the Entra ID team.

Reminder: 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

Languages

TypeScript 7.0 preview

We continued to work with the TypeScript team to improve VS Code's support for the upcoming TypeScript 7 release. TypeScript 7 is a complete rewrite in native code and offers dramatically better performance.

The TypeScript 7 preview has almost complete type checking support, and the TypeScript team has been busy adding editor features too. Recent highlights include auto import completions, rename support, and references code lenses.

You can try out TypeScript 7.0 today by installing the TypeScript (Native Preview) extension. Then run the TypeScript (Native Preview): Enable (Experimental) command in a JavaScript or TypeScript file to switch all IntelliSense to use the native preview. Checkout the most recent TypeScript 7 blog post for a full update on TypeScript 7 and the general direction of the TypeScript project.

We plan to continue working closely with the TypeScript team to improve TypeScript 7's VS Code support. Once TypeScript 7 is ready, our longer term plan is to switch to it as the default experience powering VS Code's JavaScript and TypeScript IntelliSense. If you need to use an older TS version or need editor features like TypeScript service plugins that can't be easily ported to TypeScript 7, we're planning to continue supporting existing TypeScript versions for the foreseeable future alongside TypeScript 7.0+.

Remote Development

The Remote Development extensions, allow you to use a Dev Container, remote machine via SSH or Remote Tunnels, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.

Highlights include:

  • SSH reconnection grace time control

You can learn more about these features in the Remote Development release notes.

Enterprise

Learn more about the enterprise capabilities of VS Code in our documentation.

Control auto approval for agent tools

Setting: chat.tools.eligibleForAutoApproval

Specific agent tools can be risky to use without explicit user approval, especially those that can perform destructive actions, access sensitive data, or run arbitrary code in the background (for example, runTask).

You can now define which tools are eligible for auto-approval with the new chat.tools.eligibleForAutoApproval setting. When a tool is denied from auto-approval, users won't have the option to always approve this tool in chat and must explicitly approve each use.

Organizations can enforce this behavior via an enterprise policy across their users to enhance security when using agents.

Disable the use of agents by policy

When an enterprise policy disables the use of agents in chat, the Agents picker now better communicates why they're not available.

Screenshot of the Agent picker shows agent mode unavailable due to enterprise policy.

Support GitHub Enterprise policies in Codespaces

You can specify policies for your enterprise or organization in GitHub that are applied in VS Code. For example, you can configure the MCP registry URL to be used by developers in your organization.

In this release, we added support for these policies when using VS Code with GitHub Codespaces. When a developer opens a Codespace, the same policies are applied automatically, as they already are when using VS Code locally.

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:

  • Pull request and issue implicit context when a pull request or issue webview is active.
  • Pull requests and issues can be added explicitly as context to chat sessions through "Add Context".
  • Copilot pull requests can be marked ready for review, approved, and auto-merge set with a single button.

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

Proposed APIs

Contributed Chat Context

We have a new API proposal to let extensions contribute context providers for chat. This enables extensions to provide rich context from their own domain to be used in chat sessions. For example, the GitHub Pull Request extension provides the following context:

  • Workspace context, with information about the current repository, branch, and pull request.
  • Implicit pull request and issue context when a pull request or issue webview is active.
  • Explicit pull request and issue context when the user adds them via "Add Context".

The API is still in the early stages, so expect changes to come. We'd love to get feedback on what parts of the proposal will solve extension authors' needs. You can find the proposal here: vscode.proposed.chatContextProvider.d.ts.

Engineering

Builds rollout

We've started progressively rolling out Insiders build releases over a 4-hour time window. This means that, as an Insiders user, you might receive the update notification a bit later than usual. If you're in a hurry, you can always run Check for Updates to force the update to be applied immediately.

We'll roll out the November 2025 (1.107) release to Stable users over a 24-hour time window. Just like Insiders, you can always run Check for Updates to force the update to be applied immediately.

Improved website search functionality

We've improved our website with fast, client-side search that allows you to easily and quickly navigate across our documentation.

We've open-sourced the library behind this functionality: you can download docfind and use it for your projects today! We'll follow up with a blog post on the innovations behind this tech.

Updated build scripts run directly as TypeScript

This iteration, we cleaned up our build scripts to make them easier to work with and maintain. These build scripts were a mix of compiled TypeScript, TypeScript files run using ts-node, and JavaScript. Many of these scripts were not type checked and were using commonjs (require) instead of modern modules with import and export. Even worse, many of the TypeScript build scripts required checking in the compiled JS output to our source control. What a mess!

Thankfully Node 22.18+ now allows running scripts directly as TypeScript. This lets us incrementally convert our build scripts to modern TypeScript. We used the follow tsconfig options to make sure our new TypeScript code could be run directly by Node:

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "noEmit": true, // Don't generate .js files
    "erasableSyntaxOnly": true, // Only allow TypeScript syntax that node can strip out. Enums and namespaces for example are not allowed
    "allowImportingTsExtensions": true, // Allow importing of .ts files
    "verbatimModuleSyntax": true // Make sure imports will be valid when the script is run by node directly
  }
}

GitHub Copilot helped automate many of the required changes, such as converting old commonjs files to modules and adding type annotations.

One thing to keep in mind is that while Node can run TypeScript code, it doesn't actually type check it. You still need to use tsc for that. For vscode, we're actuall using ts-go, which can fully type check all of our build scripts in well under a second.

It's pretty amazing to be able to run node build/hygiene.ts directly. Switching fully to TypeScript also lets us modernize and bring type safety to our build scripts, which will make it much easier to understand and make changes to them. Plus it enabled us to delete around 15,000 lines of compiled JS code that we previously had to keep checked in!

Copilot extensions unification

Setting: chat.extensionUnification.enabled

We have fully rolled out inline suggestions to be served from the GitHub Copilot Chat extension. As part of this change, the GitHub Copilot extension will be disabled by default for all users.

If you run into any issues with inline suggestions, please report them. You can temporarily revert to the previous behavior by setting chat.extensionUnification.enabled to false, which reenables the GitHub Copilot extension.

Note that we are planning to fully deprecate the GitHub Copilot extension in January 2026, at which point the chat.extensionUnification.enabled setting will also be removed.

Notable fixes

  • vscode#233635 - Add an action to close other windows
  • vscode#262817 - Running "Move Editor into Previous Group" from the left-most group should create a new group to the left
  • vscode#264569 - Setting and removing window.activeBorder color does not reset the window border color
  • vscode#140186 - Cannot open local terminal when remote container is opened as a workspace
  • vscode#228359 - Relaunching the terminal will often just close the terminal
  • vscode#232420 - Terminal Cursor is at the wrong place with Python3.13
  • vscode#247568 - Terminal Ctrl+Click on a file with colon in filename does not open the file, preceding zeroes are deleted
  • vscode#275011 - Getting strange terminal message when opening VS Code in WSL on a trusted workspace
  • vscode#275417 - Tasks with reveal:never, close:true no longer work on WSL
  • vscode#277311 - Add "X" button to remove command from "recently used" list in Command Palette
  • vscode#282222 - SCM - improve git blame/timeline/graph hover rendering. Thanks to Stanislav Fort (Aisle Research)
  • vscode-python-environments#1000 - Environment activation is not working reliably with "Command Prompt"

Thank you

Issue tracking

Contributions to our issue tracking:

Contributions to vscode:

Contributions to vscode-copilot-chat:

Contributions to vscode-js-debug:

Contributions to vscode-pull-request-github:

Contributions to vscode-python-debugger:

Contributions to vscode-python-environments:

Contributions to language-server-protocol:

Contributions to node-native-keymap:

Contributions to node-pty:

Contributions to python-environment-tools: