Visual Studio Code Release Notes

Welcome to the 1.115 release of Visual Studio Code.

Happy Coding!

April 2, 2026

• Enable showing test coverage indicators in the minimap.
• Add support for pasting files (for example, images) into the terminal by using Ctrl+V, drag-and-drop, and right-click paste.
• Background terminals automatically notify the agent when commands complete, including the exit code and terminal output. Prompts for input in background terminals are also detected and surfaced to the user.
• Add support for pinch-to-zoom gestures on Mac in the integrated browser.
• Update code serve-web CLI command to support --disable-telemetry, --default-folder, and --default-workspace options.

April 1, 2026

• The Copilot status bar entitlements and usage information is available in Sessions.
• Add support for connecting to remote machines over SSH, automatically installing the CLI and starting it in agent host mode.
• Track and restore file edits in agent sessions, delivering diffs, undo/redo, and state restoration for customizations made during a session.

March 31, 2026

• Chat can now track and link to browser tabs that were opened or interacted with during a session, so agents can reference open web pages.
• The send_to_terminal tool lets agents send commands to background terminals with user confirmation, fixing an issue where run_in_terminal with a timeout would move terminals to the background and make them read-only.
• Rename agent sessions from the client side via a new client-to-server rename capability in the Agent Host Protocol.
• Open web pages now show their favicons in the Go to File quick pick list, matching the favicon display on browser tab labels.

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

Original source Report a problem

Welcome to the 1.114 release of Visual Studio Code. This release focuses on streamlining your chat experience.

• Preview videos: preview videos in the image carousel for chat attachments and the Explorer context menu.
• Copy chat response: copy the final Markdown chat response for easy sharing.
• Troubleshooting chat: use /troubleshoot to diagnose chat customization issues in previous sessions.
• Simplified workspace search: get faster, more consistent semantic search results.

Happy Coding!

Chat experience

Preview videos in the image carousel

Settings: imageCarousel.chat.enabled, imageCarousel.explorerContextMenu.enabled

The image carousel, introduced in version 1.113, now also supports videos. You can play and navigate videos from chat attachments or the Explorer context menu.

The viewer includes:

• Video playback with controls
• Navigation for all images and videos using arrows or thumbnails

Copy final response in chat

The Chat view already has commands to copy the entire conversation or a specific response. However, that also includes the agent's thinking process and tool calls.

For those cases where you only want to copy the final response, there is now a Copy Final Response command in the chat context menu that copies the last Markdown section of the agent's response, after all tool calls have run.

Workspace search simplification

The #codebase tool lets Copilot do a semantic search of your codebase. This can be especially useful for finding relevant code snippets in codebases with tens to hundreds of thousands of files.

When the #codebase tool was first introduced, it was designed for Copilot's ask flow: you ask a question or request an edit and Copilot produces a result directly in its response. Now that almost all Copilot interactions are agentic, with agents able to run multiple tools and iterate before producing an edit or response, much of the original #codebase design is no longer relevant.

The first important change is that #codebase is now purely used for semantic searches. Previously, it could fall back to less accurate (and less efficient) fuzzy text searches. The agent can still do text and fuzzy searches if it wants, but we want to keep #codebase purely focused on semantic searches.

We've also simplified how the codebase index is managed. This index is what enables the #codebase tool to provide semantic search results quickly. Previously, we had the concept of both a "local index" and a "remote index". The local indexes were limited to a few thousand files and weren't always semantic. The remote index was stored remotely for a given repo, could be shared across a team, and could support millions of files.

Now there's just a single state: is your codebase semantically indexed or not? No more local vs remote. Behind the scenes, some parts of the index might still be stored on your machine and some might come from remote sources, however you no longer have to manage these indexes yourself.

Here's what all of these changes mean for using Copilot:

• The #codebase tool is now always semantic and provides consistent results.
• Copilot automatically uses #codebase for semantic searches when it makes sense. We build indexes for you on demand and use them automatically. You do not have to manage the index yourself.
• Workspaces that previously were shown as being indexed will need to be reindexed. This is typically because they were using a local, non-semantic index.
• Especially large codebases without a GitHub repo might not currently be indexable. We are slowly rolling out support for indexing these as well.

Even if your workspace is not semantically indexed, we've found you can still get good results through Copilot's other search methods (text, grep, symbols).

All these changes should make working with agents faster and provide higher quality context to the models. We also believe they simplify using Copilot and understanding what tools are available to it.

For more details, see the workspace guide.

Troubleshoot previous chat sessions (Preview)

Settings: github.copilot.chat.agentDebugLog.enabled, github.copilot.chat.agentDebugLog.fileLogging.enabled

The troubleshoot skill (invoked via /troubleshoot) helps with diagnosing chat issues by analyzing agent debug logs and surfacing insights into the agent's behavior. For example, to investigate why custom instructions were ignored or responses are slow.

With this release, you can now reference any previous chat session when troubleshooting. This makes it easier to investigate issues after the fact, without needing to reproduce them.

To troubleshoot a previous session, use the /troubleshoot command and include #session in your prompt. This will trigger a session picker where you can select from a list of your previous chat sessions.

Tip: You can also attach a session by selecting + (Add Context) > Sessions.

Languages

TypeScript 6.0

Our JavaScript and TypeScript support now uses TypeScript 6.0. This major update includes important fixes and improvements. Importantly, this TypeScript release also deprecates a number of older options in preparation for the TypeScript 7.0 rewrite.

You can read all about the TypeScript 6.0 release on the TypeScript blog.

Python

• Various bug fixes in the Python Environments extension for env file notifications and environment manager selection priority:
  • The workspace's saved interpreter selection now takes precedence over terminal-activated virtual or conda environments across restarts.
  • The env file change notification now includes a "Don't Show Again" option to permanently dismiss it.
• The Python Environments extension now recommends the community Pixi extension when Pixi environments are detected, and includes Pixi in the environment manager priority order.

Enterprise

Group policy to disable Claude agent

Administrators can now use a group policy to disable the Claude agent integration in chat. When this policy is applied, the github.copilot.chat.claudeAgent.enabled setting is managed by the organization and users cannot enable the Claude agent.

This policy is configured as a boolean with key Claude3PIntegration. Learn more about device management policies in the enterprise documentation.

Contributions to extensions

GitHub Pull Requests

There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:

• Branch names in the create PR view are now cached for faster target branch loading.
• GitHub permalink links in PR and issue overview webviews now open the corresponding local file when the file exists in the workspace.

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

Proposed APIs

Fine-grained tool approval

Language model tools with an approval flow can now scope approval to a specific combination of arguments.

For example, the built-in "Run VS Code Command" tool can run any VS Code command. A user might feel comfortable always approving editor.action.formatDocument, but not other commands. With this API, the tool implementation can scope approval to the specific command, so users approve each command individually.

See the full API proposal for more details: Fine grain tool approval.

See an example of the API in use in the Copilot Chat extension.

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Notable fixes

• microsoft/vscode #303908 Fix VS Code shortcuts taking precedence over page shortcuts in Integrated Browser
• microsoft/vscode #299777 Fix "Add Element to Chat" not working while debugging is paused in the Integrated Browser

Thank you

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

Contributions to vscode:

• @a77ming: Fix wrapped title spacing on the agent sessions welcome page PR #304686
• @AshtonYoon (Ashton Yoon): Fix janky scrolling in markdown preview with code blocks PR #287050
• @buley (Tay): fix: destroy read streams to prevent file descriptor leaks PR #303395
• @ConsoleTVs (Erik C. Forés): fix(mcp): resolve env vars in agent plugin MCP server definitions PR #303156
• @jonathanrao99 (Jonathan Thota): browser: prevent new tab from flashing in quick pick PR #304297
• @ShehabSherif0 (Shehab Sherif):
  • Fix operator precedence in fuzzyScore2 test assertion PR #304449
  • Fix copy-paste bug in performance view blocking startup count PR #304452
• @Tyriar (Daniel Imms): Remove self from notify, classifier, events, etc. PR #304498
• @xingsy97 (xingsy97):
  • Keyboard layout - replace all dashes/dots in macOS layout labels PR #303971
  • Editor - fix paste preference filter matching all providers PR #304044
  • Settings editor - avoid repeated extension list refresh PR #303957
  • settings: use local StopWatch to avoid timing corruption between concurrent searches PR #304361
  • mergeEditor: optimize removeDiffs from O(K*N) to single-pass O(N) PR #304404
  • timeline: fix memory leak when toggling pane visibility PR #304668
  • notebook: fix unused cell lookup and broken selection deduplication PR #305105
  • Chat - remove deprecated prompt attribute spelling PR #301976
• @yogeshwaran-c (Yogeshwaran C):
  • fix: prevent terminal panel from overwriting terminalEditorActive context key PR #304802
  • fix: modernize HTML sample snippet PR #304818
  • fix: make testing icon colors inherit from list error/warning foreground PR #304959
  • fix: enable zoom for SVGs without explicit width/height dimensions PR #304973
  • fix: persist test coverage sort order across sessions PR #304979
  • fix: send user preferences to TS server even without visible editor PR #304987

Contributions to vscode-pull-request-github:

• @Daniel-Aaron-Bloom: Link to local file for permalinks in webview PR #8583

Contributions to monaco-editor:

• @pgoslatara (Pádraic Slattery): chore: Update outdated GitHub Actions versions PR #5214

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Welcome to the 1.113 release of Visual Studio Code. This release includes various improvements across the agent and developer experience.

• Chat customizations: Manage all chat-related customizations from a single, unified interface.
• Configurable thinking effort: Control a model's reasoning level directly from the UI.
• Nested subagents: Allow subagents to invoke other subagents for complex multi-step workflows.
• CLI agent capabilities: Use MCP servers, fork sessions, and view debug logs in CLI agents.
• Images preview: Preview images from chat with the full-featured image viewer.
• Default themes refresh: Enjoy a fresh new look with updated default light and dark themes.

Happy Coding!

VS Code is rolling out gradually to all users. Use Check for Updates in VS Code to get the latest version immediately.

To try new features as soon as possible, download the nightly Insiders build, which includes the latest updates as soon as they are available.

Agent experience

Use the same tools and workflows across local, CLI, and Claude agents, and compose multi-step automations with less friction.

MCP support in Copilot CLI & Claude agents

Previously, MCP servers that you configured in VS Code were only available to local agents running in the editor. This release adds support for MCP servers in Copilot CLI & Claude agents.

MCP servers you have registered in VS Code are bridged to Copilot CLI and Claude agents. This applies to both user-defined servers and servers defined in your workspace via mcp.json files.

Learn more about using MCP servers in VS Code.

Forking sessions in Copilot CLI & Claude agents

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

Forking a session enables you to create a copy of an existing session at any point in the conversation history. This is useful when you want to explore a different line of thought or try out different prompts without losing the context of the original session.

As of this release, you can now also fork sessions in both Copilot CLI (Experimental) and Claude agents. To enable forking for Copilot CLI, enable the github.copilot.chat.cli.forkSessions.enabled setting.

Learn more about forking a chat session in the documentation.

Agent debug logs for Copilot CLI and Claude CLI sessions (Preview)

The Agent Debug Log panel is the primary tool for understanding what happens when you send a prompt. It shows a chronological event log of agent interactions during a chat session. You can now use the Agent Debug Log panel for Copilot CLI and Claude agent sessions. Support for local agent sessions was already available.

Learn more about the Agent Debug Log panel in our documentation.

Claude session listing powered by SDK APIs

VS Code now adopts the official API from the Claude agent SDK to list out sessions and their messages. Previously, we relied on parsing Claude JSONL files on disk, which had a risk of being out of sync if Claude changed their structure. If you experienced issues with the Claude agent not showing all your sessions or messages, this should now be resolved.

Nested subagents

Setting: chat.subagents.allowInvocationsFromSubagents

Subagents can now invoke other subagents, enabling more complex multi-step workflows. Previously, subagents were restricted from calling other subagents to prevent infinite recursion. With the new chat.subagents.allowInvocationsFromSubagents setting, you can enable this capability when needed.

Learn more about using subagents in the documentation.

Manage plugin marketplaces

We added a new command Chat: Manage Plugin Marketplaces that lists all configured plugin marketplaces. For each marketplace, you can browse the plugins, open their local directory, and remove them.

Learn more about using agent plugins in the documentation.

URL handlers for plugin installation

You can trigger VS Code plugin installation via URL handlers. To install a marketplace, you can trigger a link with the format:

vscode://chat-plugin/add-marketplace?ref=<source>

Where "source" is a Github repo/owner or a base64-encoded Git URI. To install an extension, you can use the following format:

vscode://chat-plugin/install?source=<source>

To target VS Code Insiders, replace vscode with vscode-insiders in the URL.

Chat experience

Tailor the AI to your project from a single editor, control how much a model reasons before responding, and review visual context without leaving chat.

Chat Customizations editor (Preview)

The Chat Customizations editor provides a centralized UI for creating and managing all your chat customizations in one place. The editor organizes customization types into separate tabs, such as custom instructions, prompt files, custom agents, and agent skills. It also provides an embedded code editor with syntax highlighting and validation.

You can create new customizations from scratch or use AI to generate initial content based on your project. To add MCP servers and agent plugins, browse the corresponding marketplace directly from the editor.

To open the editor, select the Configure Chat (gear icon) in the Chat view or run Chat: Open Chat Customizations from the Command Palette (Ctrl+Shift+P).

Learn more about the Chat Customizations editor in the documentation.

Configurable thinking effort in model picker

Models that support reasoning, such as Claude Sonnet 4.6 and GPT-5.4, now show a Thinking Effort submenu directly in the model picker. You can use this to control how much reasoning the model applies to each request without navigating to VS Code settings. VS Code retains the selected effort level per model across conversations.

Choose a reasoning model in the picker and select the arrow to reveal the available effort levels. The available effort levels might vary by model. Non-reasoning models do not show the submenu.

The model picker label now also displays the selected effort level, for example "GPT-5.3-Codex · Medium", to make it easier to see which effort level is currently active for each model.

Learn more about thinking effort and reasoning in the documentation.

Note: The github.copilot.chat.anthropic.thinking.effort and github.copilot.chat.responsesApiReasoningEffort settings have been deprecated. Reasoning effort is now configured directly through the model picker.

Images preview for chat attachments

Setting: imageCarousel.chat.enabled, imageCarousel.explorerContextMenu.enabled

When you work with images in chat, whether you attached screenshots to your request or the agent generated images via tool calls, you can now select any image attachment to open it in a full image viewer experience.

The viewer opens as a modal overlay and supports:

• Navigation: Browse all images from the current chat session by using arrow buttons, keyboard arrows, or the thumbnail strip at the bottom.
• Sections: Images are grouped by conversation turn, so you can see which images came from a particular request or response.
• Zoom & pan: Click to zoom in, use Option+Click (Mac) or Ctrl+Click (Windows/Linux) to zoom out, or scroll/pinch to zoom continuously. At high zoom levels, scroll to pan around the image.

The image viewer is now also available from the Explorer view context menu for image files. When you select Open in Images Preview, the viewer opens with all images from the current folder.

Both features are enabled by default. To configure them independently, use imageCarousel.chat.enabled and imageCarousel.explorerContextMenu.enabled.

Editor experience

Develop and test web apps more confidently in the integrated browser, and enjoy a refreshed default look for the editor.

Use self-signed certificates in the integrated browser

When you are developing web applications that depend on secure HTTPS connections, it's usually necessary to use a self-signed certificate during testing.

Under normal circumstances, such certificates shouldn't be trusted. Previously, any site that presented an untrusted certificate would simply fail to load in the integrated browser, without any option to bypass.

Now, similar to most browsers, you can choose to temporarily trust a certificate that can't be verified, to unblock development in these scenarios.

When you proceed, connections to the current host using that certificate are allowed for one week. The URL bar will show that the connection isn't secure, with the option to revoke trust at any time.

Learn more about the integrated browser in the documentation.

Improved browser tab management

Setting: workbench.browser.showInTitleBar

Managing open tabs can already be difficult. As we encourage more use of integrated browser tabs, we are also adding more controls to easily manage them.

• Quick Open Browser Tab

This command opens a Quick Pick that displays all open browser tabs and allows them to be quickly filtered, focused, and closed.

The command can also be triggered with the Ctrl+Shift+A keyboard shortcut while a browser is currently focused, or via a new shortcut button in the VS Code title bar, visible when a browser tab is open.

The visibility of this button is configurable via the workbench.browser.showInTitleBar setting.

• Close All Browser Tabs

Browser tab context menus now have an option to close all browser tabs in the same group, similar to the existing "Close All" item. Browser tabs across all groups can also be closed via the Command Palette.

New default themes

VS Code now ships with new default themes: "VS Code Light" and "VS Code Dark". These themes are designed to provide a fresh, modern look while maintaining the familiarity and usability of the previous default "Modern" themes. In addition, OS theme syncing will default to the new themes for new users, so that VS Code will automatically match the light/dark mode of your operating system with the new themes.

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Thank you

Issue tracking

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

Contributions to vscode:

• @jcansdale (Jamie Cansdale): Use bracketed paste for multiline executed terminal text PR #302526
• @jeevaratnamputla: Replace child_process.exec with execFile to prevent potential command injection PR #291825
• @kbhujbal (Kunal Bhujbal): Fix code quality issues: error logging and JSDoc typo PR #297893
• @sathvikc (Sathvik C): fix: prevent duplicate tip nodes on re-entrant renderGettingStartedTipIfNeeded PR #302317
• @ShehabSherif0 (Shehab Sherif): Fix missing global flag in sanitizeId regex PR #303603
• @xingsy97 (xingsy97): Git - optimize worktree ignored-path computation PR #303955

Contributions to vscode-copilot-chat:

• @24anisha (Anisha Agarwal):
  • Search subagent -- resolve relative and absolute paths PR #4429
  • System prompt updates to handle search subagent PR #4500
• @etvorun (ET): Fix: NES debounce and language context fetch do not honor cancellation token PR #4384

Contributions to vscode-python-environments:

• @00zayn: Fix spurious unresolved interpreter warning from ${workspaceFolder}-scoped global defaultInterpreterPath PR #1334
• @StellaHuang95 (Stella Huang): Add telemetry for manager registration failures PR #1365

Contributions to vscode-windows-process-tree:

• @ZA139: feat：Add getAllProcesses API for retrieving all system processes PR #84

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Visual Studio Code 1.112

Release date: March 18, 2026

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

Welcome to the 1.112 release of Visual Studio Code. This release includes various improvements across the agent and developer experience.

• Integrated browser debugging: debug web apps end-to-end without leaving VS Code.
• Copilot CLI permissions: give Copilot CLI sessions more autonomy so they complete tasks with fewer interruptions.
• MCP server sandboxing: run local MCP servers in a sandbox to limit what they can access on your machine.
• Agent image support: work with screenshots, diagrams, and binary files directly in agent conversations.
• Monorepo customizations: share agent instructions and skills across all packages in a monorepo.

Happy Coding!

VS Code is rolling out gradually to all users. Use Check for Updates in VS Code to get the latest version immediately.

To try new features as soon as possible, download the nightly Insiders build, which includes the latest updates as soon as they are available.

Agent experience

Give agents more autonomy, richer context, and easier diagnostics so they can handle complex tasks with less intervention.

• Message steering and queueing in Copilot CLI

  For local agent sessions, you can send messages while a previous request is running, to steer the agent towards a different response or queue up follow-up messages. This release adds support for steering and queueing messages to Copilot CLI sessions.

• Preview changes before delegating to Copilot CLI

  When you have uncommitted changes in your workspace and try to delegate a task to Copilot CLI, you can choose to copy, move, or ignore those changes in the worktree that Copilot CLI creates for the session. However, you had to check the Source Control view to see what those changes were before making a decision.

• In this release, the Chat view now shows the list of pending changes, making it easier to see what can be migrated over to the worktree created when delegating to Copilot CLI.

• Clickable file links in Copilot CLI terminal output

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

  The terminal's file link detection now recognizes paths generated by Copilot CLI that reference files under the ~/.copilot/session-state/ directory. Previously, these paths were not resolved correctly because the built-in link detector did not know about the Copilot CLI session-state directory structure.

  The link detector now handles both absolute and relative paths: absolute and tilde-prefixed paths open directly, while relative paths are resolved against the active session-state directory with a fallback to workspace folders.

  This feature is enabled by default and can be toggled with the github.copilot.chat.cli.terminalLinks.enabled setting.

• Permissions levels in Copilot CLI

  Setting: chat.autopilot.enabled

  You can configure permissions for local agent sessions in chat, to give agents more autonomy in their actions and reduce the number of approval requests. This release adds this capability to Copilot CLI sessions as well.

  For Copilot CLI sessions, you can choose between the following permission levels:
  • Default Permissions: uses your configured approval settings. Tools that require approval show a confirmation dialog before they run.
  • Bypass Approvals: auto-approves all tool calls without showing confirmation dialogs and automatically retries on errors.
  • Autopilot: (enabled by default in Insiders) auto-approves all tool calls, auto-responds to questions, and continues working autonomously until the task is complete. Enable Autopilot with chat.autopilot.enabled setting.

• Troubleshoot agent behavior with /troubleshoot (Preview)

  Settings: github.copilot.chat.agentDebugLog.enabled, github.copilot.chat.agentDebugLog.fileLogging.enabled

  There are several agent customization options available in VS Code. If your chat agents are not behaving as expected, it can be difficult to understand why. For example, when instructions, skills, or agents are not applied correctly or when a response is unexpectedly slow.

  To help with this, we are introducing a new /troubleshoot skill that analyzes the agent debug logs directly in the conversation and provides insights into the agent's behavior. Type /troubleshoot in the chat input, followed by a question or description of the issue you're experiencing.

  The skill reads the JSONL debug log files that are exported from the chat session and can help you understand why tools or subagents were used or skipped, why instructions or skills did not load, what contributed to slow response times, and whether network connectivity problems occurred.

  To use the /troubleshoot skill in chat, enable the following settings and reload VS Code:
  • github.copilot.chat.agentDebugLog.enabled: enables agent debug logging
  • github.copilot.chat.agentDebugLog.fileLogging.enabled: writes debug logs to JSONL files on disk

• Export and import agent debug logs (Preview)

  Setting: github.copilot.chat.agentDebugLog.enabled

  The Agent Debug Logs panel in VS Code gives you a detailed view into the agent's behavior for a session, including tool usage, subagent decisions, and more. Previously, only the active session's debug information was available in the panel.

  You can now export and import debug logs for agent sessions, allowing you to share them with others or analyze them offline. This is especially useful for troubleshooting and sharing insights about agent behavior.

  Note: Importing files larger than 50 MB shows a warning dialog with the actual file size. Consider trimming the file or exporting a shorter session if you encounter this warning.

• Image and binary file support for agents

  Setting: chat.imageSupport.enabled, imageCarousel.explorerContextMenu.enabled

  Agents can now read image files from disk and binary files natively, which allows you to use agents for a wider variety of tasks, such as analyzing screenshots, reading data from binary files, and more. Binary files are presented to the agent in a hexdump format.

  When an agent or tool generates an image as output, such as a screenshot from the integrated browser, those images are now selectable in chat responses and can be opened in a dedicated image carousel view. Enable this functionality with the chat.imageSupport.enabled setting (Experimental).

  When imageCarousel.explorerContextMenu.enabled (Experimental) is enabled, you can right-click image files or folders in the Explorer view and select Open Images in Carousel to browse images in the carousel view.

  Note: The image carousel is currently experimental.

• Automatic symbol references

  When you copy a symbol, such as a class name, function, or method name, and paste it into chat, VS Code now automatically pastes it as a symbol reference #sym:Name. This gives the agent automatic context about the symbol, which enables it to complete tasks more quickly and efficiently.

  If you want to paste a symbol without it being converted to a symbol reference, you can use the Paste as Text command, via Ctrl+Shift+V (Cmd+Shift+V on macOS).

• Agent extensibility

  Scale your agent setup across projects with shared customizations, and keep it secure with tighter control over MCP servers and plugins.

• Customizations discovery in parent repositories

  Setting: chat.useCustomizationsInParentRepositories

  In monorepo setups, you often open a package or subfolder in VS Code instead of the repository root. Previously, chat customizations were only discovered from the current workspace folder. With the new chat.useCustomizationsInParentRepositories setting, VS Code can also discover customization files from parent folders up to the repository root.

  This improved discovery makes it easier to share repository-wide guidance and tools across packages in a monorepo without needing to open the full repository as your workspace.

  When discovery is enabled, it applies to all chat customization types, including always-on instructions such as copilot-instructions.md, AGENTS.md, and CLAUDE.md, along with instruction files, prompt files, custom agents, skills, and hooks.

• Parent-repository discovery only applies when:
  • Your open workspace folder is not itself a Git repository
  • A parent folder contains the .git folder
  • The parent repository is trusted with workspace trust

• Sandbox locally running MCP servers

  Running MCP servers locally can pose security risks as they have the same permissions as the user running VS Code, which enables them to access files or network resources they shouldn't need for their functionality.

  To reduce this risk, you can now run locally configured stdio MCP servers in a sandboxed environment on macOS and Linux. Sandboxed servers have restricted file system and network access.

  To enable sandboxing, set "sandboxEnabled": true for a server in your mcp.json file. When a sandboxed server needs access to an additional folder or domain, VS Code prompts you to grant that permission and updates the sandbox configuration for that mcp.json file. All servers defined in the same mcp.json file share that sandbox configuration.

  Note: Sandboxing for locally running MCP servers is not currently available on Windows. Remote scenarios, such as WSL and SSH, continue to work.

• Improved UI for MCP elicitation

  When an MCP server requires additional information to complete a request, it can trigger an elicitation form to collect that information from the user. These elicitation forms now use the same UI as the Ask Questions tool, allowing for a more consistent and user-friendly experience when providing additional information to MCP servers.

• Enable or disable plugins and MCP servers

  Previously, plugins and MCP servers could only be disabled or enabled by installing or uninstalling them. This release introduces the ability to enable or disable plugins and MCP servers without uninstalling them.

  Both plugins and MCP servers can now be enabled and disabled both globally and per-workspace. You can do this by opening the MCP or plugin page, or by right-clicking on their entries, either in the Extensions view or the Chat: Open Customizations view.

• Automatic plugin updates

  Setting: extensions.autoCheckUpdates

  Plugins can now update automatically based on the extensions.autoCheckUpdates setting. Plugins from npm and pypi require approval to update, as updating these plugins might cause new code to be run on your machine.

Developer experience

Build and debug web apps without leaving VS Code, with a more capable integrated browser and streamlined editor workflows.

• Integrated browser

  Debug web apps with the integrated browser

  The integrated browser lets you open web apps directly within VS Code, and now you can also start debugging sessions with the integrated browser. This allows you to interact with the web app, set breakpoints, step through code, and inspect variables without ever leaving VS Code.

  We added a new editor-browser debug type that enables debugging of integrated browser tabs with both Launch and Attach configurations.

  Most options from existing msedge and chrome debug configurations are supported, which makes migration often as simple as changing the type of an existing configuration in launch.json.

• Integrated browser UX improvements

  Setting: workbench.browser.pageZoom

  • Context menus
  Right clicking in a browser page now exposes common options such as copy/paste, open in new tab, and inspect.

  • Independent zoom level
  The integrated browser now has its own zoom level, independent from the VS Code window's zoom. Use the Zoom In (Ctrl+=), Zoom Out (Ctrl+-), and Reset Zoom (Ctrl+Numpad0) shortcuts when the browser has focus, or use the actions from the URL bar menu. The zoom level is remembered per website, just like in a regular browser.

• Auto-close Find dialog after search

  A new editor.find.closeOnResult setting lets you automatically close the Find control after a match is found and move focus back to the editor.

  The setting is disabled by default, preserving the existing behavior where the Find dialog stays open after a search.

Terminal

• Improved IME composition for the terminal

  When typing with an Input Method Editor (IME) near the right edge of the terminal, the composition preview text could previously overflow outside the terminal boundaries. The composition view is now constrained to the available space between the cursor and the terminal's right edge. As you enter new characters, older characters are progressively hidden, keeping the preview text within the terminal viewport. This matches the behavior of other modern terminals such as Ghostty.

  Note: On Windows, enable terminal.integrated.windowsUseConptyDll for the best IME composition experience.

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Notable fixes

• xtermjs/xterm.js #5737: Fix ^C not working to end for newer fish + kitty keyboard protocol
• microsoft/vscode-python #25849: Prevent double/triple activation from two extensions

Thank you

Issue tracking

Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

Contributions to vscode:
• @12LuA (Luca): Fix: comment typo in authIssuers proposal PR #300899
• @DrSergei (Sergei Druzhkov): Fix variable updating after set response PR #299473
• @eliericha (Elie Richa): Make variable resolvers based on environment including launch config env PR #299752
• @jcansdale (Jamie Cansdale): fix: chunk multiline PTY writes on macOS to avoid 1024-byte buffer corruption PR #298993
• @jeanp413 (Jean Pierre): Support terminal creation on web worker extension host when there's remote authority PR #300897
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #299892
• @lammmab (Liam): hide "Ask for Edits" affordance when AI features are disabled PR #300563
• @murataslan1 (Murat Aslan): fix: wrap long docstrings in parameter hints widget PR #292258
• @SimonSiefke (Simon Siefke): fix: memory leak in MainThreadWorkspace PR #283450
• @tamuratak (Takashi Tamura): markdown-language-features: enhance document link handling with improved URI parsing and selection PR #296821
• @xingsy97 (xingsy97): Enrich terminal tool result metadata for AI agent workflows PR #300034

Contributions to vscode-copilot-chat:
• @24anisha (Anisha Agarwal): Add conversation_id to search subagent telemetry PR #4326
• @aashna (Aashna Garg): Add sticky_threshold and sticky_override to router decision API PR #4359
• @dennyac (Denny Abraham Cheriyan): Add resolved model for events PR #4210
• @IanMatthewHuff (Ian Huff): More repo info telemetry check to support windows repo perf issues PR #4339

Contributions to vscode-docs:
• @karlhorky (Karl Horky): Reword "Secondary Side Bar" docs for default-visible state PR #9540
• @mariaghiondea (Maria Ghiondea): Update publishing extensions doc to reflect soft delete changes PR #9544
• @putku45: Fix grammar in Refactoring documentation PR #9525; Fix typos in October 2017 release notes PR #9524; Fix grammar in JSON completions section PR #9526

Contributions to node-pty:
• @ritschwumm: Fix typo in documentation comment PR #897

Contributions to python-environment-tools:
• @lingyaochu (Xin Zhao): Only embed Windows resources for binary targets PR #374

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Visual Studio Code 1.111

Release date: March 9, 2026

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

Welcome to the 1.111 release of Visual Studio Code, the first of our weekly Stable releases! This release further enhances the agent experience with the following features:

• Agent permissions: adjust the autonomy level of your agents for each session.
• Autopilot (Preview): let your agents iterate autonomously until they complete their task.
• Agent-scoped hooks (Preview): attach pre- and post-processing logic for an agent without affecting other chat interactions.
• Agent troubleshooting: troubleshoot agent behavior and customizations with debug events snapshots.

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.

Autopilot and agent permissions

Setting: chat.autopilot.enabled

The new permissions picker in the Chat view lets you control how much autonomy the agent has. The permission level applies only to the current session. You can change it at any time during a session by selecting a different level from the permissions picker.

You can choose from the following permission levels:

• Default Approvals: Uses your configured approval settings. Tools that require approval show a confirmation dialog before they run.
• Bypass Approvals: Auto-approves all tool calls without showing confirmation dialogs and automatically retries on errors.
• Autopilot (Preview): Auto-approves all tool calls, automatically retries on errors, auto-responds to questions, and the agent continues working autonomously until the task is complete.

Autopilot (Preview)

Autopilot is enabled by default in Insiders. You can activate it in Stable by enabling chat.autopilot.enabled.

Behind the scenes, the agent stays in control and iterates until it signals completion by calling the task_complete tool.

Note: Bypass Approvals and Autopilot bypass manual approval prompts and ignore your configured approval settings, including for potentially destructive actions like file edits, terminal commands, and external tool calls. The first time you enable either level, a warning dialog asks you to confirm. Only use these levels if you understand the security implications.

Learn more about Autopilot and agent permissions in our documentation.

Agent scoped hooks (Preview)

Setting: chat.useCustomAgentHooks

Custom agent frontmatter now supports agent-scoped hooks that are only run when you select the specific agent or when it's invoked via runSubagent. This lets you attach pre- and post-processing logic to specific agents without affecting other chat interactions.

To create an agent-scoped hook, define it in the hooks section of the YAML frontmatter of your .agent.md file.

To try this feature, enable the chat.useCustomAgentHooks setting. For more information, see Agent-scoped hooks in our documentation.

Debug events snapshot

To help you understand and troubleshoot agent behavior, you can now attach a snapshot of agent debug events as context in chat by using #debugEventsSnapshot. Use it to ask the agent about loaded customizations, token consumption, or to troubleshoot agent behavior.

You can also select the sparkle chat icon in the top-right corner of the Agent Debug panel to add the debug events snapshot as an attachment to the chat composer. Selecting the attachment opens the Agent Debug panel logs, filtered to the timestamp when the snapshot was taken.

Learn more about Debugging chat interactions in our documentation.

Chat tip improvements

The chat experience evolves rapidly and we want to make sure you are aware of new features and improvements. We redesigned the chat tips experience to better surface relevant tips at the right time in your chat journey.

Chat tips now guide you through a structured onboarding journey. Foundational tips, such as using the Plan agent and creating a custom agent are shown first. After you complete or dismiss the foundational tips, quality-of-life tips like experimental settings or generating Mermaid diagrams are shown in random order.

Additional chat tip improvements include:

• Tips are only displayed when a single chat session is visible, such as in the Welcome view or Chat view. If multiple chat editors are open, tips are hidden to reduce clutter.
• Tips include keyboard shortcuts to help you discover relevant key bindings.
• Tips are hidden after you act on or dismiss them for the current session.
• We added tips for the /init and /fork slash commands. The /init tip helps you discover the command for initializing project configuration, and the /fork tip introduces manual conversation forking, which lets you branch a conversation to explore different approaches.

AI CLI profile group in terminal dropdown (Experimental)

Setting: terminal.integrated.experimental.aiProfileGrouping

AI CLI terminal profiles, such as GitHub Copilot CLI, are now displayed in a dedicated group at the top of the terminal profile dropdown for improved discoverability. To enable this feature, turn on the terminal.integrated.experimental.aiProfileGrouping setting.

Extension authoring

Basic IntelliSense for localized strings in extension package.json files

VS Code supports localizing strings in an extension's package.json. This iteration, we added a few basic IntelliSense features that make working with these localized strings easier.

• Go to Definition: Jump to or peek at the definition of a localized string in the package.nls.json file.
• Find all References: See all the places a localized string is referenced in either the package.json or package.nls.json file.

Engineering

With the move to weekly Stable releases, we continue to improve our engineering processes to ship high-quality features at a faster pace.

Test plan item creation

We added a one-click experience for creating test plan items from feature request issues. This reduces the manual steps needed to set up structured testing plans for new features.

Verification step generation

As test plan items are assigned randomly to engineers, clear verification steps are crucial for efficient and effective testing. We added a button to generate verification steps on relevant issues. This helps ensure that issues have clear, structured steps for verifying fixes and features before they are closed.

Automatic PR media attachment to linked issues

When you merge a pull request that includes an image or GIF in its description, the media content is now automatically posted as a comment on the linked issue. This streamlines the verification process by making it easier to see the visual demonstration of a fix or feature directly on the issue.

Chat showcase pipeline

A new automated pipeline processes issues that are labeled with chat-showcase. When a showcase issue is identified, a corresponding chat tip issue is automatically created, making it easier to add tips for features.

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Notable fixes

Thank you

Contributions to vscode :

• @cathaysia (cathaysia): fix(json.schemaDownload.trustedDomains): avoid always update json.sch… PR #298423
• @eliericha (Elie Richa): include debug extension host env in shell env (#_241078) PR #298276; Include remote debug extension host env in remote terminal shell env PR #299007
• @jaidhyani (Jai Dhyani): editor: add 'foldedLine' unit to cursorMove command PR #296106
• @neruthes (Neruthes 0x5200DF38): fix editor punctuation width PR #297741
• @RajeshKumar11: MCP Gateway: avoid blocking list calls on startup PR #298040
• @Rohan5commit (Rohan Santhosh): docs: fix duplicated wording in proposed API comment PR #298522
• @sanchirico (John Sanchirico): Fix chat terminal flicker during streaming PR #298598

Contributions to vscode-copilot-chat :

• @24anisha (Anisha Agarwal): Exempt Search Subagent tool result from write to disk PR #4219
• @arieluchka (Ariel Agranovich): docs: incorrect documented jaeger port. <------ easy fix PR #4251
• @bharatvansh (Ayush Singh): Avoid reporting subagent token usage to the context window widget PR #3515

Contributions to language-server-protocol :

• @dietrichm (Dietrich Moerman): Fix link to Neovim's LSP documentation PR #2236
• @MariaSolOs (Maria Solano): Update metamodel PR #2234

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

February 2026 (version 1.110)

Release date: March 4, 2026

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

Welcome to the February 2026 release of Visual Studio Code. This release makes agents practical for longer-running and more complex tasks, giving you more control and visibility, new ways to extend agents, and smarter session management.

• Agent plugins: install prepackaged bundles of skills, tools, and hooks from the Extensions view
• Agentic browser tools: let the agent drive the browser to interact with your app and verify its own changes
• Session memory: persist plans and guidance across conversation turns
• Context compaction: manually compact conversation history to free up context space
• Fork a chat session: create a new, independent session that inherits conversation history to explore alternative approaches
• Agent Debug panel: get real-time visibility into agent events, tool calls, and loaded customizations
• Chat accessibility: use chat to its fullest with screen reader improvements, keyboard navigation, and notification signals
• Create agent customizations from chat: generate prompts, skills, agents, and hooks directly from a conversation
• Kitty graphics protocol: render high-fidelity images directly in the integrated terminal

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.

Agent controls
Whether you are debugging an agent's behavior, tweaking approval flows, or handing work off to a background process, these updates give you more visibility and control over how agents run.

Background agents
With background agents, you can hand off tasks to Copilot CLI, while still keeping track of them in VS Code. We have made several improvements to align the capabilities and experience of background agents with local and cloud agents.

• Context compaction: Copilot automatically compacts the conversation history when the context window reaches its limit. You can now also manually trigger compaction for background agents with the /compact slash command.
• Use /slash commands: chat customization options like prompt files, hooks, and skills are now also available in background agent sessions as slash commands.
• Rename background agent sessions: you can now rename your background agent sessions to keep track of them more easily.

Claude agents
Last month, we added Claude agents, enabling you to interact with the Claude Agent SDK using Claude models included in your GitHub Copilot subscription.

This month, we've expanded this experience with new features and improvements:

• Steering and queuing to let you send follow-up messages mid-conversation to alter the agent's approach or to queue up additional requests.
• Session renaming
• Context window rendering with compaction
• Additional slash commands
◦ /compact for on-demand compaction
◦ /agents to manage custom agents
◦ /hooks to manage Claude hooks
• Add the getDiagnostics tool to let the agent access editor and workspace problems
• Significant performance improvements

More improvements are planned. Share your feedback on GitHub!

Agent Debug panel (Preview)
With different agent customizations like hooks, skills, and custom agents, it can sometimes be difficult to understand what happens when you send a message to an agent. The Agent Debug panel gives you deeper visibility into your chat sessions and how your chat customizations are loaded.

The Agent Debug panel shows chat events in real time, including chat customization events, system prompts, tool calls, and more. You can see exactly which prompt files, skills, hooks, and other customizations are loaded for a session, making it easier to understand and troubleshoot your agent configuration. This replaces the old Diagnostics chat action with a richer, more detailed view.

Open the panel from the Command Palette with Developer: Open Agent Debug Panel, or select the gear icon at the top of the Chat view and choose View Agent Logs.

The panel also includes a chart view that displays a visual hierarchy of events, so you can quickly understand the structure and sequence of what happens during a chat session.

This experience is still in preview, so try it out and share your feedback!

Note: The Agent Debug panel is currently only available for local chat sessions. Log data is not persisted, so you can only view logs for chat sessions from your current VS Code session.

Slash commands for enabling auto approval
You can now toggle global auto approve directly from the chat input using slash commands, without navigating to settings:

• /autoApprove enables global auto approve for all tools
• /disableAutoApprove disables global auto approve

/yolo and /disableYolo are aliases for the same commands.

CAUTION: Global auto approve skips all tool confirmation prompts, letting the agent run tools and terminal commands without waiting for your approval. This can speed up longer, multi-step tasks but means you won't have the opportunity to cancel potentially destructive actions. Make sure you understand the security implications before enabling it and consider using terminal sandboxing for additional protection.

Edit and ask mode changes
Setting: chat.editMode.hidden

As agents have evolved, agent mode now handles everything edit mode can do and more, with better performance and reliability. Edit mode is now hidden from the agent picker by default, so users benefit from the most capable mode without having to choose between options. You can bring it back by disabling the chat.editMode.hidden setting.

Ask mode is now backed by a custom agent definition, making it a fully agentic experience. This resolves previous limitations, such as requiring a new session when switching between ask and agent mode.

Both changes demonstrate how to customize your own agents. If you prefer edit mode or want your own version of ask mode, create a custom agent that matches your needs by defining its tools, prompt, and language model. When you disable chat.editMode.hidden, you can select the View edit agent action in the agent picker to view the agent declaration that powers edit mode, which can serve as a starting point for your own custom agent.

Learn how to create custom agents in the custom agents documentation.

Ask questions tool
The askQuestions tool, which presents a question carousel UI during chat interactions, has been moved into VS Code core. This improves reliability when canceling requests and enables the tool to work consistently across different contexts, including subagents.

When the carousel is active, you can now send a steering message without needing to reply to or dismiss pending questions first. This allows you to redirect the agent's response on the fly, even in the middle of a question sequence. Use the keyboard to navigate between questions with unassigned (next) and unassigned (previous).

Prevent auto-suspend during chat
VS Code now asks the operating system not to automatically suspend the machine while a chat request is running. You can step away from your computer without worrying about interrupting the agent's response.

Note that closing the lid of an unplugged laptop still triggers suspension.

Agent extensibility
Agents are only as useful as the tools and customizations you give them. This release makes it easier to extend what agents can do, from installable plugin bundles to browser automation and new code-aware tools.

Agent plugins (Experimental)
Settings: chat.plugins.enabled, chat.plugins.marketplaces, chat.plugins.paths

VS Code now supports agent plugins, which are prepackaged bundles of chat customizations. Plugins can contain skills, commands, agents, MCP servers, and hooks.

You can search and install agent plugins directly from the Extensions view within VS Code. Enter @agentPlugins in the search box or run the Chat: Plugins command from the Command Palette.

By default, VS Code retrieves plugins from the copilot-plugins and awesome-copilot repos. You can configure more sources via the following settings:

• chat.plugins.marketplaces: add additional plugin marketplaces by specifying GitHub or plain git repositories. The setting can also support Claude-style marketplaces such as anthropics/claude-code.
• chat.plugins.paths: register local plugin directories by specifying their paths and enabling or disabling them.

Learn more about agent plugins in the agent plugins documentation.

Agentic browser tools (Experimental)
Setting: workbench.browser.enableChatTools

In the previous release, we added a new integrated browser in VS Code desktop which lets you interact with web pages directly within the editor. But what if your agent could autonomously use this browser and validate changes to your website while it's building it?

In this release, we added a set of tools for agents to read and interact with the integrated browser. As the agent interacts with the page, it sees updates to page content and any errors and warnings in the console. The tools work out of the box without the need to install any extra dependencies.

• Page navigation: openBrowserPage, navigatePage
• Page content and appearance: readPage, screenshotPage
• User interaction: clickElement, hoverElement, dragElement, typeInPage, handleDialog
• Custom browser automation: runPlaywrightCode

These tools give agents the ability to perform simultaneous authoring and verification of web apps and close the development loop for agents.

By default, pages opened by the agent run in private, in-memory sessions. This gives you control over what browsing data the agent can access. To give the agent access to a specific web page in the integrated browser, you can explicitly share the page with the agent to give temporary access and any saved data.

To try out the new tools, enable workbench.browser.enableChatTools and enable the browser tools in the chat tools picker.

Get started with the browser agent testing guide for a step-by-step tutorial.

Create agent customizations from chat
You can now generate agent customization files directly from a chat conversation by using new /create-* slash commands in agent mode:

• /create-prompt: generate a reusable prompt file
• /create-instruction: generate an instruction file for project conventions
• /create-skill: extract a multi-step workflow into a skill package
• /create-agent: create a specialized custom agent persona
• /create-hook: create a hook configuration for lifecycle automation

Each command guides you through the creation process and lets you choose between user-level (account-wide) or workspace-level (project-specific) storage.

The commands can also extract patterns from an ongoing conversation. For example, after debugging an issue over several turns, use /create-skill to capture the procedure as a reusable skill, or /create-instruction to turn corrections into project conventions.

You don't need to remember the exact slash command. You can also use natural language, such as "save this workflow as a skill" or "extract an instruction from this", and the agent recognizes your intent and starts the correct creation flow.

The same generation options are available from the quick pick menus for prompts, instructions, skills, and agents, indicated by a sparkle icon.

Tools for usages and rename
We have updated the usages -tool and also added a tool for rename. These tools reuse existing extension or LSP capabilities and allow agents to navigate and refactor code with high precision and best performance.

Agents should automatically pick up these new tools. However, we have found that agents have a strong preference for using grep instead, which is inferior for this scenario. You can help the agent by explicitly #-mentioning the tool names, like Use #rename and change the name of fib to fibonacci or by setting up a SKILL.md file.

Smarter sessions
Long-running and multi-turn tasks work better when the agent remembers context, delegates research efficiently, and keeps your inline edits in sync. These improvements make sessions more resilient and context-aware.

Session memory for plans
Plans created by the Plan agent now persist to session memory and stay available across conversation turns. When you ask for refinements, the agent builds on the existing plan instead of starting from scratch.

The plan is also recalled after unrelated messages in the same session, so you can return to a plan without repeating context. During longer implementation work, the plan remains accessible in memory even when older conversation history is compacted to free up context space.

Context compaction
As a conversation grows, the accumulated messages and context can fill up the model's context window. Context compaction summarizes the conversation history to free up space, so you can continue working in the same session without losing important details.

VS Code automatically compacts the conversation when the context window reaches its limit, but you can also trigger compaction manually. Manual compaction is available for local, background, and Claude agent sessions. To manually compact, use one of the following methods:

• Type /compact in the chat input field. Optionally, add custom instructions after the command to guide how the summary is generated, for example /compact focus on the database schema decisions.
• Select the context window control in the chat input box, and then select Compact Conversation.

Learn more about context compaction in the documentation.

Codebase search with Explore subagent
Setting: chat.exploreAgent.defaultModel

The Plan agent now always delegates codebase research to a dedicated Explore subagent. Explore is a read-only agent that uses only search and file read tools, and focuses on fast, parallelized codebase exploration. By offloading research to Explore, the Plan agent can produce plans that reference specific files and code paths in your workspace.

Explore runs on fast models by default (Claude Haiku 4.5, Gemini 3 Flash) to keep research quick while the Plan agent uses the full model for planning. You can override the model with the chat.exploreAgent.defaultModel setting. Hover over the explore task in chat to see which model is being used for research.

Note: Explore is not directly invokable as a standalone agent. It is only available as a subagent used on-demand.

Inline chat and chat session
When an agent session already changed a file, inline chat now always queues new messages into that session instead of making changes in isolation. This ensures that the full context is used and is also useful when reviewing agent edits.

Fork a chat session
You can now fork a chat session to create a new, independent session that inherits the conversation history from the original. This is useful when you want to explore an alternative approach, ask a side question, or branch a long conversation in a different direction without losing the original context.

There are two ways to fork a session:

• Fork the entire session: type /fork in the chat input box to create a new session with the full conversation history.
• Fork from a checkpoint: hover over any chat request and select Fork Conversation to create a new session that includes only the conversation up to that point.

The forked session is fully independent—changes in one session do not affect the other. Learn more about forking chat sessions.

Chat experience
Small refinements to the chat interface add up: a cleaner model picker, less visual clutter from tool output, and notifications that reach you even when you are heads-down in another file.

Redesigned model picker
We have redesigned the language model dropdown to improve selecting the right model for the task. The new dropdown organizes models into clear sections:

• Auto is always shown at the top of the list.
• Featured and recently used models appear next. Up to four recently used models are shown alongside featured models curated for your account. As you use models, they move into this section automatically.
• Other models is a collapsible group that contains the remaining available models. Expanding it also reveals the Manage Models option at the bottom.
• A search box lets you quickly filter models by name.

Each model entry shows a rich hover with model details such as capabilities and context window size. Models that are unavailable on your current GitHub Copilot plan are also shown but are not selectable.

Discover features with contextual tips (Experimental)
Setting: chat.tips.enabled

VS Code now shows contextual tips in the Chat view to help you discover features and get the most out of your AI coding experience. Tips appear when you start a new chat session and are tailored to your usage patterns. To avoid being overwhelming, only features you haven't tried yet are suggested, making them relevant and actionable.

Tips cover a variety of capabilities including:
• Creating custom agents, prompts, and skills
• Using message queueing and steering
• Switching to better models
• Enabling experimental features like YOLO mode and custom thinking phrases

Use the navigation controls to browse through available tips, or dismiss individual tips you're not interested in. Tips automatically hide once you've used the suggested feature. You can disable tips entirely with chat.tips.enabled.

New tips are added regularly as features are released, so check back often for fresh suggestions.

Custom thinking phrases
Settings: chat.agent.thinking.phrases

The loading text that is shown during reasoning or during tool calls is now customizable. You can use the predefined custom phrases to complete the existing default phrases with the replace mode, or have custom phrases be an addition to the existing default phrases with append.

This setting lets you personalize the chat loading experience.

Collapsible terminal tool calls
Settings: chat.tools.terminal.simpleCollapsible

Terminal tool invocations in agent mode are now displayed as collapsible sections. Instead of long terminal outputs cluttering the conversation, each terminal command appears as a summary header that you can expand to reveal the full output. This reduces visual noise and makes it easier to scan through multi-step agent interactions. This functionality can be disabled with the chat.tools.terminal.simpleCollapsible setting.

OS notifications for chat responses and confirmations
Settings: chat.notifyWindowOnResponseReceived, chat.notifyWindowOnConfirmation

Previously, OS notifications for chat responses and confirmation requests only appeared when VS Code was not focused. This meant that if you were actively working on another task in VS Code, you might miss important updates like when a response is received or when the agent needs your confirmation to proceed.

You can now configure these notifications to appear even when the window is in focus by setting the settings value to always.

Inline chat hover mode
Setting: inlineChat.renderMode

Inline chat is transitioning away from the "in-between lines" UI to a hover-based UI. You can enable it via inlineChat.renderMode, which makes the inline chat input more like the rename experience. Once a prompt is submitted, progress and results are shown in the upper right corner.

Inline chat affordance
Setting: inlineChat.affordance

To provide an easier way of starting inline chat, we added two kinds of affordances that show alongside your selection. They combine with the lightbulb and should not get in your way.

The inlineChat.affordance setting has three possible values:
• off No affordance is shown on text selection
• editor Show a menu in the editor alongside the selection
• gutter Show a menu in the editor gutter (line number area) next to the selection

Accessibility
This release improves screen reader support, keyboard navigation, and awareness of chat interactions so that every developer can work effectively with VS Code's AI features.

Toggle thinking content in the accessible view
Screen reader users can now toggle the inclusion of thinking content in the chat response accessible view unassigned . This lets you choose whether to include the model's reasoning process when reading responses, providing flexibility to either follow the full chain of thought or focus only on the final output.

Question carousel accessibility
The chat question carousel is now fully accessible to screen reader users:
• Questions are announced with their position (for example, "Question 1 of 3")
• Use Alt+N and Alt+P to navigate between questions
• Use unassigned to toggle focus between the question carousel and chat input
• In screen reader mode, focus no longer automatically moves to prevent disruption

Notifications for chat questions and confirmations
Settings: chat.notifyWindowOnConfirmation, accessibility.signals.chatUserActionRequired

When chat asks a question or requires confirmation, VS Code now plays an accessibility signal and shows an OS notification when enabled. This helps you stay aware of pending actions even when working in another window.

Keybinding to toggle TODO list focus
Use unassigned to quickly toggle focus between the agent TODO list and the chat input. This is particularly helpful for screen reader users to get an overview of pending tasks and return to the chat input.

Cursor position remembered in accessible view
When you close the accessible view while content is streaming (such as during a chat response), your cursor position is now preserved when you reopen it. This prevents the cursor from jumping back to the top and lets you continue reading from where you left off.

Find and filter accessibility help
Press Alt+F1 in any find or filter dialog to open contextual accessibility help. This includes help for:
• Editor find and replace
• Terminal find
• Search across files
• Output, Problems, and Debug Console filters

The help content explains available keyboard shortcuts, navigation patterns, and context-specific behaviors. Find widgets also announce "Press Alt+F1 for accessibility help" when focused (controlled by accessibility.verbosity.find).

Quick input screen reader improvements
The Go to Line dialog ( Ctrl+G ) and other quick input boxes now work better with screen readers:
• Characters are announced as you type
• Arrow key navigation works correctly within the input field
• Proper announcements when navigating list items
• Line and column position announced after navigation

Steering indicator for screen readers
When you send a steering message while a response is streaming, screen reader users now receive an aria-status announcement indicating that steering has occurred.

Accessibility skill
A new built-in accessibility skill helps ensure new features include proper accessibility support. When you ask the agent to create a new feature and make it accessible, it automatically references accessibility guidelines and patterns.

Checkmarks in chat
Settings: accessibility.chat.showCheckmarks

This iteration, in an effort to simplify the chat view and make it more consistent, checkmarks are now removed by default in front of tool calls and collapsible pieces. The accessibility.chat.showCheckmarks will re-enable checkmarks throughout the chat if you'd like to have them as indicators in the chat.

Editor Experience

Modal editors (Experimental)
Settings: workbench.editor.useModal, extensions.allowOpenInModalEditor

We are experimenting with a new modal editor experience for editors that you typically open briefly and then return to your active task. A modal editor floats on top of the editor without impacting the layout of your editor tabs. To close the modal editor, press Escape. The modal has an action to move the editor back into an editor tab, as well as an action to maximize the modal experience.

The modal experience applies to the following editors:
• Settings
• Keyboard shortcuts
• Profiles management
• AI and Language models management
• Workspace trust management

Set workbench.editor.useModal to some for opting into this experience.

Note: the Settings editor and Keyboard Shortcuts editor show a button to open the associated JSON file as a text editor

Another setting extensions.allowOpenInModalEditor expands the use of modal editors to extensions. This experience is still a work in progress and will likely change in the future but we wanted to make it available for feedback now:

In this modal editor, a control in the title bar allows you to navigate between all extensions from the list you had in the Extensions view. The same applies to MCP servers. Future versions will likely see the extensions list and search functionality also move into the modal. Try it out and share your feedback.

Configurable notification position
Setting: workbench.notifications.position

Previously, VS Code notifications appeared in the bottom-right corner of the screen. With the default position of the Chat view also on the right, notifications could obscure the chat interface.

You can now configure the position of notifications to be either top-right , bottom-right, or bottom-left . The default remains bottom-right . This setting enables you to choose the best position for your workflow.

Settings editor cleanup
We have moved the VS Code chat settings into their own top-level entry in the Settings editor with sub-categories. GitHub Copilot Chat extension entries remain in their own entry under Extensions.

The displayed list of settings is also scoped to the selected table of contents entry, meaning that once you select a table of contents entry, you cannot accidentally scroll into the next entry anymore.

Lastly, the experimental settings have been moved to the end of each section, so that stabilized settings appear first.

Code Editing

Long-distance next edit suggestions
Next edit suggestions (NES) extend ghost text by suggesting edits not just at your cursor, but also nearby, anticipating what you'd change next. We've been continuing to advance this experience with long-distance next edit suggestions, which extend NES to predict and suggest edits anywhere in your file, not just near your current cursor position.

Read the blog post on long-distance next edit suggestions to learn more about how it was built, from creating the training dataset, to refining the UX, evaluating success, and more. Make sure you have NES ( github.copilot.nextEditSuggestions.enabled ) and extended NES range ( github.copilot.nextEditSuggestions.extendedRange ) enabled in VS Code.

NES eagerness
The Copilot Status Bar item now includes an eagerness option for next edit suggestions. This option lets you choose between getting more suggestions that might be less relevant, or fewer suggestions that are more likely to be useful.

Initially, this option primarily affects the timing of suggestions. As the NES model evolves, it will increasingly take your eagerness preference into account for more fine-tuned suggestions.

Source Control

AI co-author attribution for commits
Setting: git.addAICoAuthor

VS Code can automatically append a Co-authored-by: trailer when you commit code that includes AI-generated contributions. Additionally, Git blame hover tooltips now show co-authors from commit trailers, including non-AI Co-authored-by entries.

Configure git.addAICoAuthor with one of these values:
• off (default): does not add a co-author trailer
• chatAndAgent: adds the trailer for code generated with Copilot Chat or agent mode
• all: adds the trailer for all AI-generated code, including inline completions

VS Code only adds co-author trailers for commits you make from within VS Code. This setting does not modify commits made in external Git tools or the command line.

Debugging

JavaScript Debugger

Custom property replacements
If an object has a method defined using Symbol.for('debug.properties'), then those properties will be shown by default in the debugger. This allows you to provide a more comprehensible view of complex objects.

Emulate focused window and event listener breakpoints
Previously, when debugging a browser, you could set breakpoints in the Event Listener Breakpoints view. We have renamed this view to Browser Options.

We added an extra option to Emulate a focused page. When checked, moving your focus out of the browser window no longer causes the browser element to lose focus. This is useful for debugging elements that depend on hover or focus states.

Terminal

Kitty graphics protocol
Settings: terminal.integrated.enableImages, terminal.integrated.gpuAcceleration, terminal.integrated.windowsUseConptyDll

The VS Code terminal now supports the Kitty graphics protocol, enabling high-fidelity image rendering directly in the terminal. Programs that support this protocol can transmit and display images with a rich set of capabilities:
• Image formats: PNG, 24-bit RGB, and 32-bit RGBA
• Display layout: scale images to specific column/row dimensions, crop source regions, apply sub-cell pixel offsets, and control z-index stacking order
• Transmission: direct inline base64 with chunked transfer and zlib compression support
• Image management: transmit and display in one step, store images and place them later at different positions, delete by ID or all at once, and re-transmit to update existing images
• Cursor control: choose whether the cursor moves past the image or stays in place after rendering
• Terminal integration: images scroll with text, and are properly cleaned up on terminal reset or clear

To enable image rendering, set terminal.integrated.enableImages to true and ensure terminal.integrated.gpuAcceleration is set to on or auto. On Windows, you also need to enable terminal.integrated.windowsUseConptyDll.

Tools like kitten icat (macOS/Linux) or the VT CLI can be used to display images in the terminal.

Note: Some Kitty graphics protocol features are not yet supported, including animations, relative placements, Unicode placeholders, and file-based transmission. See the xterm.js discussion for the most up-to-date implementation status.

Ghostty support for external terminal
Settings: terminal.external.osxExec, terminal.external.linuxExec

Ghostty is now supported as an external terminal on macOS and Linux. You can set it as your default external terminal using the terminal.external.osxExec setting on macOS or terminal.external.linuxExec on Linux.

Once configured, commands like Terminal: Open New External Terminal and debug configurations that launch in an external terminal will open in Ghostty.

Workspace folder selection for external terminals
When you open an external terminal in a multi-root workspace using Ctrl+Shift+C or the Terminal: Open New External Terminal command, VS Code now prompts you to select a workspace folder. The selected folder is used as the working directory for the external terminal.

Terminal sandboxing improvements (Preview)
Settings: chat.tools.terminal.sandbox.enabled, chat.tools.terminal.sandbox.linuxFileSystem, chat.tools.terminal.sandbox.macFileSystem, chat.tools.terminal.sandbox.network

Trusted domains can now be selected for network isolation by enabling allowTrustedDomains in chat.tools.terminal.sandbox.network. Improved detection of restricted domains, with clear feedback indicating which domain is blocked.

No installation is required to enable terminal sandboxing on macOS, and on Linux you can enable without installing ripgrep.

Languages

Unified JavaScript and TypeScript settings
To prepare for the upcoming TypeScript 6.0 and 7.0 releases, we've consolidated and cleaned up our built-in JavaScript and TypeScript setting IDs. Previously many of these settings had duplicate javascript.* and typescript.* versions. This is because these settings are from before we added a standard approach to language-specific settings. Some of the settings names were also inconsistent.

Now all of these settings have been moved under the js/ts.* prefix. This means that by default you only need to update a single setting value to change the behavior in both JavaScript and TypeScript files. You can use language-specific settings if you want different behavior in JavaScript and TypeScript files.

For example, instead of setting:
"javascript.format.enable": false,
"typescript.format.enable": true

You can now use language-specific overrides with the unified setting.

The old javascript.* and typescript.* settings continue to work but are now marked as deprecated and will be overridden if the new unified js/ts settings are set.

We understand this is a big change, however we think it's the right one for the long term quality of VS Code. The unified settings make it easier to change JavaScript and TypeScript settings, and also enable support for modern options such as language-specific settings.

Python

Python Environments extension rolling out to all users
The Python Environments extension is now rolling out to all users after a year in preview. The extension brings a unified interface for managing Python environments, packages, and interpreters directly in VS Code, regardless of whether you use venv, conda, pyenv, poetry, or pipenv.

Key capabilities include:
• Quick Create: Create an environment with a single click using your default manager and the latest Python version
• Python Projects: Assign environments to specific folders for monorepos and multi-service workspaces
• uv integration: Faster environment creation and package installation when uv is installed
• Built-in package management: Search, install, and uninstall packages from the Environment Managers view
• Portable settings: Environment configurations use manager types instead of hardcoded paths, making settings.json portable across machines

You can expect the extension to be enabled automatically over the next few weeks, or you can opt in immediately with the python.useEnvsExtension setting.

For more details, read the announcement blog post or see the Python environments documentation.

Contributions to extensions

GitHub Pull Requests
There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
• Multiple pull request and issue descriptions can be open at once.
• The setting githubPullRequests.autoRepositoryDetection can be set to true to include repositories that are outside of the workspace.
• Repositories without matching issues are now hidden in the Issues view.

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

Extension Authoring

Webviews and Custom Editors can now use ThemeIcons for their icon path
Webview Panels and custom editors can now use a ThemeIcon as their editor tab icon.

Portable mode detection API finalized
The env.isAppPortable API is now stable and available to all extensions without requiring enabledApiProposals.

Use this API to detect whether VS Code is running in portable mode, which is enabled when the app runs from a folder containing a data directory.

Proposed APIs

Chat item controller API
We continued to improve the chat session API. This API lets extensions contribute items to VS Code's built-in chat sessions view. Notable changes this iteration include:
• Added ChatSessionItemControllerNewItemHandler so that controllers can specify the URI used for new sessions.
• Added ChatSessionProviderOptions.newSessionOptions which sets the default options for new sessions.

We also significantly optimized the API's implementation to support large numbers of sessions.

Engineering

TypeScript-Go for VS Code engineering
We've continued adopting TypeScript-Go (tsgo) for development work in the vscode repo.

As of this iteration, we default the vscode workspace to using TSGo for development. We've already noticed performance improvements from this, and it also helps us test TSGo's language tooling.

We now also use TypeScript-Go (tsgo) to compile VS Code's built-in extensions during development. As a result, each of our built-in extensions is now built and fully typechecked in under a second.

Extension bundling with esbuild
We've migrated most of our built-in extensions to use esbuild instead of webpack for bundling. Esbuild is used for both bundling the desktop and web versions of these extensions.

This migration has both simplified and sped up our builds. There are only a handful of extensions left to migrate and we hope to finish this work in March.

Deprecated features and settings

New deprecations in this release
• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Upcoming deprecations
None

Notable fixes
• vscode#251722: Inline actions on extension provided tree-view items withing the visible scroll area even when "workbench.list.horizontalScrolling": true

Thank you

Issue tracking
Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @tamuratak (Takashi Tamura)
• @robotsnh (robotsnh)

(Additional contribution and PR acknowledgements follow in the release notes.)

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Update 1.109.1: The update addresses these security issues.
Update 1.109.2: The update addresses an issue with chat.
Update 1.109.3: The update addresses these issues and introduces several notable features:
• Message steering and queueing: send follow-up messages while a request is still running
• Agent hooks: run custom shell commands at key agent lifecycle points
• Claude compatibility: reuse your Claude configuration files directly in VS Code
• Use skills as slash commands: invoke agent skills on demand from chat
Update 1.109.4: The update addresses these issues.
Update 1.109.5: The update addresses these issues and adds these features to improve background agents:
• Support for slash commands, including prompt files, hooks, and skills
• The ability to rename background agent sessions
• Kitty keyboard support is now available to all users
Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap
Welcome to the January 2026 release of Visual Studio Code. In this release, we are further evolving VS Code to make it the home for multi-agent development.
• Chat UX - chat just feels better and snappier with faster streaming, improved reasoning results, and a revamped editor inline chat
• Agent Session Management - it's now easier to delegate tasks to agents across local, background, and cloud and jump in when needed
• Agent Customization - build your own workflows using agent orchestrations, and have consistent results with Agent Skills and organization-wide customizations
• Agent Extensibility - reuse your knowledge with Claude agent support and new Anthropic model capabilities, and enjoy rich chat interactions with MCP Apps
• Agent Optimizations - agents work smarter with Copilot Memory and experience faster code search with external indexing
• Agent Security & Trust - feel confident running terminal commands with sandboxing and effective auto-approval rules
• Workbench & productivity - test your apps without leaving the editor with the new integrated browser
• Terminal Enhancements - quality-of-life improvements to make your terminal experience smoother and more reliable
• Coding & Editor - several impactful improvements to make everyday coding smoother
• Extensions & API - new capabilities for extension authors to build richer experiences
Happy Coding!
Watch our VS Code 1.109 release highlights video to hear about these features!
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.
Upcoming events
Agent Sessions Day
Join us for Agent Sessions Day on Feb 19th to see these latest updates demoed live! Discover how VS Code has evolved into a unified agent UX, while staying true to its core values of openness, extensibility, and developer choice.
Chat UX
Faster responses, clearer reasoning, and less friction. This release brings streaming improvements that show progress as it happens, a revamped inline chat that stays out of your way, and better visibility into what the model is thinking, so you can stay in flow while the AI works.
Message steering and queueing (Experimental)
Setting: chat.requestQueuing.enabled, chat.requestQueuing.defaultAction
Update 1.109.3: When working on longer tasks, you often think of the next task before the current or notice the agent heading in the wrong direction. Previously, you had to wait for a response to complete or cancel it entirely. Now you can send follow-up messages while a request is still running.
While a request is in progress, the Send button changes to a dropdown with three options:
• Add to Queue: your message waits and sends automatically after the current response completes.
• Steer with Message: signals the current request to yield after finishing the active tool execution, then processes your new message immediately. Use this to redirect the agent when it's heading in the wrong direction.
• Stop and Send: cancels the current request entirely and sends your new message immediately.
When you have multiple pending messages, drag and drop them to change the order in which they are processed.
Use chat.requestQueuing.defaultAction to set the default action of the Send button to steer (default) or queue.
Learn more about message steering and queueing in the documentation.
Anthropic models now show thinking tokens
Settings: chat.thinking.style, chat.agent.thinking.collapsedTools, chat.agent.thinking.terminalTools, chat.tools.autoExpandFailures
Many of you are using Anthropic's Claude models in VS Code. These models now support thinking tokens to give you more visibility into the model's reasoning process.
In this release, we've enhanced the chat UX to surface thinking tokens more effectively. More information, less noise!
• Choose between detailed or compact thinking styles to suit your preference (chat.thinking.style).
• You'll see the model's thought process interleaved with tool calls and responses (chat.agent.thinking.terminalTools).
• Failing tool calls automatically expand to show more context (chat.tools.autoExpandFailures).
• Various visual enhancements to make following model activity more intuitive, like scrollable thinking content and shimmer animations.
Mermaid diagrams in chat responses
Chat responses can now render interactive Mermaid diagrams with the renderMermaidDiagram tool. This lets models use flowcharts, sequence diagrams, and other visualizations to visually break down complex concepts. The diagrams are interactive, so you can pan and zoom to explore them in detail, or open them in a full-sized editor for easier viewing.
Interact with Mermaid diagrams using the following controls:
• Pan and zoom - Hold Alt/Option and use the mouse wheel to zoom, or pinch to zoom on a trackpad. Hold Alt/Option and drag to pan around the diagram.
• Click to zoom - Hold Alt/Option and click to zoom in. Add Shift to zoom out.
• Open in editor - Use the button to open the diagram in a full-sized editor for better viewing of larger diagrams.
• Copy source - Right-click on a diagram and select Copy diagram source to copy its Mermaid source code.
Ask Questions tool (Experimental)
Setting: chat.askQuestions.enabled
Instead of making assumptions when something is unclear, the agent can now use the askQuestions tool to ask clarifying questions during chat conversations. It presents one or more questions directly in chat with single/multi-select options, free text input, and recommended answers highlighted for quick decisions.
Use the keyboard to navigate between answers with Up and Down, or type the number that matches the corresponding answer (use Escape to skip remaining questions).
We have revamped our Plan agent to also take advantage of the askQuestions tool to make sure your implementation plans align with your expectations and beyond!
Plan agent
The built-in Plan agent lets you create a structured implementation plan before starting to code. This helps ensure that the AI understands the task requirements and produces high-quality code that meets your expectations.
• The Plan agent now follows a structured 4-phase iterative workflow that produces higher-quality implementation plans:

• Discovery - Autonomously explores your codebase, searching for relevant files and understanding project structure.
• Alignment - Pauses to ask clarifying questions before committing to a plan, catching ambiguities early.
• Design - Drafts a comprehensive implementation plan with clear steps, file locations, and code snippets.
• Refinement - Adds verification criteria and documents decisions made during planning.
  • You can now invoke the Plan agent by typing /plan in chat, followed by your task description. This provides a quick entry point for planning complex tasks before switching to implementation.
  Context window details
  To keep track of how the model is using its context window, you can now see a context window indicator in the chat input area. Hover over the indicator to see a breakdown of token usage by category.
  Inline chat UX revamp (Preview)
  Settings: inlineChat.affordance, inlineChat.renderMode
  We continue to revamp the inline chat experience and have two preview features:
  • An affordance that makes it easier to trigger inline chat when selecting text (inlineChat.affordance)
  • A lightweight and easier-to-use contextual rendering (inlineChat.renderMode)
  Model descriptions in the model picker
  On hover or keyboard focus of a model in the model picker, you can now see its details at a glance.
  Terminal command output
  Richer command details
  To make it clearer what command is being run, the terminal tool now shows additional details:
  • Syntax highlighting for inline Node, Python, and Ruby
  • Working directory
  • Description of the command's intent
  Output streaming
  Terminal output now automatically expands when a command takes time to execute, giving you immediate visibility into what's happening. Quick commands stay collapsed to reduce visual noise.
  Interactive input
  Embedded terminals are now fully interactive. You can focus the terminal and type directly, which is useful when a command prompts for confirmation or requires user input. The cursor is now visible, making it clear when a terminal is ready for input.
  Delete all hidden terminals
  The Hidden Terminals item in the terminal panel now includes a delete icon to clear all hidden terminals with one action.
  Tell us what you think about our new themes (Experimental)
  We are developing new experimental VS Code Light and VS Code Dark themes to increase focus and bring a sense of elevation and lightness to the UI, through the use of shadows and transparency. These themes are a work-in-progress.
  Let us know what works and where we can improve by giving feedback in the vscode repository.
  VS Code Dark (Experimental):
  VS Code Light (Experimental):
  Edit mode is now hidden (Experimental)
  Setting: chat.editMode.hidden
  Edit mode is now hidden by default from the agent dropdown in chat. Using agents provides a superset of edit mode capabilities and produces better results for code editing tasks.
  If your organization has disabled agent mode, edit mode remains visible in the agent dropdown. You can also manually restore edit mode by disabling the chat.editMode.hidden setting.
  Agent Session Management
  Delegate, monitor, and switch without losing focus. You can now run multiple agent sessions in parallel across local, background, and cloud environments, all from a single unified view. Jump between sessions, track progress at a glance, and let agents work independently while you stay productive.
  Switching and delegating between agent types
  VS Code makes it easy to start agent sessions across different environments: locally in VS Code, in the background, in the cloud, or with other agent providers. We've made it easier to switch between these different agent types by introducing a new session type picker in the chat input area.
  The picker serves two main purposes:
  • Choose the type of agent session you want to start
  • Hand off an ongoing session to a different agent type (for example, plan a task locally and implement in the cloud)
  Keeping track of agent sessions
  Keeping track of your active agent sessions is essential when working with multiple agents, especially when you have multiple parallel session across different environments.
  Agent Sessions view
  We've further improved the Agent Sessions view in VS Code to make this task easier:
  • Resize the sessions list when showing side-by-side
  • Multi-select sessions to perform operations in bulk
  • Better stacked view to improve navigating sessions and applying filters
  Agent status indicator
  Settings: chat.agentsControl.enabled, chat.agentsControl.clickBehavior
  In situations where you have multiple active sessions, it's important to quickly see which sessions need your attention. We added an agent status indicator (chat.agentsControl.enabled) in the VS Code command center to provide visibility into agent session updates.
  The indicator shows different types of status information: in-progress, unread, and sessions that need your attention. Select the indicator to quickly open and filter the sessions list.
  We have also updated the chat button in the command center to let you configure its behavior when clicked (chat.agentsControl.clickBehavior). By default, it now cycles through the different Chat view states: sidebar, maximized, or hidden.
  Subagents
  Setting: chat.customAgentInSubagent.enabled
  Agents can run subtasks using subagents to break down complex tasks into smaller parts. The nice thing about subagents is that they operate in their own dedicated context window and don't add up to the main agent's context window.
  Subagents can now run in parallel, which can significantly speed up tasks that can be split into independent tasks.
  To provide more visibility into what the different subagents are doing, the chat conversation now shows details such as what tasks it's doing, the custom agent used for the subagent, and whichever tool is currently used. You can expand the subagent information to show the full details of what it's doing, including the full initial prompt it was provided with and the result it returned.
  Search subagent (Experimental)
  Setting: github.copilot.chat.searchSubagent.enabled
  Searching your codebase is typically a task that can involve multiple iterations and which can quickly add up to your context window limit. We added support for a search subagent that runs in an isolated agent loop, enabling it to iteratively refine searches, try multiple queries, and explore different parts of your workspace.
  This improves the quality of search results for complex queries where a single search isn't sufficient. It also preserves the main agent's context window and enables it to continue working while the search subagent does its job.
  Cloud agents
  When you start a new cloud agent session, you now have more options to configure your session. Choose from different models, use one of your custom agents, or select from available partner agents (where available).
  • Model selection for cloud agents
  • Third-party coding agents (Preview): If you have third-party coding agents, such as Claude and Codex, configured as part of your GitHub Copilot subscription, VS Code will show these options after selecting the cloud agent type.
  • Custom agents for cloud agents: Choose from custom Agents available in your target GitHub repository default branch.
  • Multi-root workspace and empty workspace improvements: When in a multi-root workspace window or empty workspace window, you can now select the folder to be used for the cloud agents.
  • Checkout always shows: The Checkout option for agent sessions now shows even when the GitHub Pull Requests extension is not installed. When you select this action, it installs GitHub Pull Requests if needed, and then hands off to it to perform the checkout.
  Background agents
  Aligning with local and cloud agents, we have added several improvements to background agents:
  • Custom agents for background agents
  • Attach images as context
  • Multi-root workspace improvements: When in a multi-root workspace, you can now select the folder to be used in background agents.
  • Auto-commit at the end of each turn: We have updated the background agent loop to commit the changes to the Git worktree at the end of each turn. This enabled us to remove the Keep/Undo actions for background sessions and simplify how changed files are shown in the working set.
  • /slash commands for background agents: Update 1.109.5: Prompt files, hooks, and skills are now available to background agents as slash commands in chat.
  • Rename background agents sessions: Update 1.109.5: You can now rename your background agent sessions to keep track of them more easily.
  Agent sessions welcome page (Experimental)
  Setting: workbench.startupEditor
  Last but not least, we're experimenting with a new welcome page and need your help to make it great. When you have multiple agents working in parallel, keeping track of recent sessions matters. The new welcome page surfaces your agent sessions front and center.
  Enable the welcome page as your startup editor by setting workbench.startupEditor to agentSessionsWelcomePage. Let us know what you think and send us feedback in the vscode repository!
  Agent Customization
  Shape how AI works with your codebase and share it across your team. Agent Skills now let you package domain expertise into reusable workflows, organization-wide instructions ensure consistency, and new controls give you fine-grained control over how and when agents get invoked.
  Agent hooks (Preview)
  Setting: chat.hooks.enabled
  Update 1.109.3: Hooks let you execute custom shell commands at key lifecycle points during agent sessions. Unlike instructions or custom prompts that guide agent behavior, hooks run your code deterministically with guaranteed outcomes. Use them to enforce security policies, automate code quality checks, create audit trails, or inject project-specific context.
  VS Code supports eight hook events that fire at specific points during a session, including PreToolUse and PostToolUse for intercepting tool calls, SessionStart and Stop for session lifecycle, and SubagentStart and SubagentStop for tracking nested agent usage.
  VS Code uses the same hook format as Claude Code and Copilot CLI, so you can reuse existing hook configurations across tools.
  To get started, use the /hooks slash command in chat to configure a new hook, or create a hook file manually. For example, you can create a PreToolUse hook that runs a linter after every file edit, or block dangerous terminal commands before they execute.
  Learn more about agent hooks in the documentation.
  Use skills as slash commands
  Agent Skills are now available as slash commands in chat, alongside prompt files. Type / in the chat input to see all available skills and prompts, and select a skill to invoke it immediately. You can add extra context after the command, for example /webapp-testing for the login page or /github-actions-debugging PR #42.
  By default, all skills appear in the / menu. Use the user-invokable and disable-model-invocation frontmatter properties in your skill files to control how each skill is accessed:
  • Set user-invokable: false to hide a skill from the menu while still letting the model load it automatically.
  • Set disable-model-invocation: true to show the skill in the menu but prevent the model from loading it on its own.
  Learn more about using skills as slash commands in the documentation.
  Set up your workspace for AI with /init
  With always-on custom instructions like copilot-instructions.md or AGENTS.md, you can ensure that the AI uses your project's conventions for generating code.
  To prime your project with an initial set of instructions based on your codebase, you can now use the /init slash command in chat to generate or update your workspace instructions.
  When you run /init, the agent discovers existing AI conventions in your workspace (such as copilot-instructions.md or AGENTS.md), analyzes your project structure and coding patterns, and generates comprehensive workspace instructions tailored to your project. The /init command is implemented as a contributed prompt file, so you can customize its behavior by modifying the underlying prompt.
  Agent Skills are generally available
  Settings: chat.useAgentSkills, chat.agentSkillsLocations
  Agent Skills are now generally available and enabled by default. Skills provide specialized capabilities, domain knowledge, and refined workflows to help the AI produce high-quality outputs. Each skill folder contains tested instructions for specific domains like testing strategies, API design, or performance optimization.
  You can now manage skills in VS Code in the same way you manage prompt files, instructions, or custom agents. Use the Chat: Configure Skills command to view all available skills, or Chat: New Skill File to create a new skill in your workspace or user home.
  By default, VS Code looks for skills definitions in the .github/skills and .claude/skills folder of your workspace, or in the ~/.copilot/skills or ~/.claude/skills folder in your user home. You can specify custom paths where VS Code should look for skills by using the chat.agentSkillsLocations setting.
  If you're an extension author, you can also package and distribute skills with your extension by including them in the extension and registering them using the chatSkills contribution point in the package.json.
  The path must point to a directory that contains a SKILL.md file, and the name field in the SKILL.md frontmatter must match the parent directory name. For example, if the path is ./skills/my-skill, the directory must contain a SKILL.md with name: my-skill in its frontmatter. Learn more about the required folder structure in the Agent Skills documentation.
  Organization-wide instructions
  Setting: github.copilot.chat.organizationInstructions.enabled
  Previously, VS Code already added support for organization-level custom agents. In this release, VS Code now also supports organization-level custom instructions. If your GitHub organization has configured custom instructions for Copilot, they are automatically applied to your chat sessions, ensuring consistent guidance across your team.
  This feature is enabled by default. You can disable organization instructions by setting github.copilot.chat.organizationInstructions.enabled to false.
  Learn more about Custom Instructions in the documentation.
  Custom agent file locations
  Setting: chat.agentFilesLocations
  Like for other customization files, such as prompt files, instructions, and skills, you can now configure where VS Code looks for custom agent definitions (.agent.md).
  By default, VS Code searches for agent files in your workspace's .github/agents folder. With the new chat.agentFilesLocations setting, you can add additional directories to search, making it easier to organize and share agents across projects or keep them in a central location outside your workspace.
  Control how custom agents are invoked
  Settings: chat.customAgentInSubagent.enabled
  Custom agents now support additional attributes in the frontmatter header that give you more control over how agents can be invoked. This is particularly useful for setting up agent orchestrations to handle complex tasks with confidence.
  • user-invokable: controls whether the agent can be selected from the agents dropdown in chat. Set to false to create agents that are only accessible programmatically or as subagents.
  • disable-model-invocation: prevents the agent from being invoked as a subagent by other agents when enabled. This is useful for agents that should only be triggered explicitly by users.
  • agents: limits which subagents the current agent can invoke. When specified, the agent can only hand off work to the listed agents. Use the agent tool to enable subagent invocation.
  The use of custom agents as subagents is currently still behind a setting. Enable chat.customAgentInSubagent.enabled to enable custom agents as subagents.
  Multiple model support for custom agents
  Custom agents can now specify more than one model in the frontmatter header. The first available model in the list is used, providing fallback options if a preferred model is unavailable.
  Chat customization diagnostics
  Chat customization files can originate from various locations, including your user profile, workspace, extensions, and your GitHub organization. When troubleshooting issues with custom agents, prompts, instructions, or skills, it can be challenging to determine which files are currently loaded and whether any errors occurred during loading.
  A new diagnostics view helps you troubleshoot chat customization issues by showing all currently loaded custom agents, prompt files, instruction files, and skills. To access it, right-click in the Chat view and select Diagnostics. This opens a Markdown document listing all active customization files, their load status, and any errors that occurred during loading.
  Language Models editor
  The Language Models editor in VS Code provides a centralized interface for managing and configuring language models used in chat. This iteration, we further enhanced this experience:
  • Multiple configurations per provider: create multiple configurations for the same model provider, each with a different API key. This is useful for separating personal and work accounts, or using different API keys for different projects. For example, you might have one Gemini configuration with your personal API key and another with your team's API key.
  • Configuring models from Azure provider: when configuring Azure models, VS Code opens the chatLanguageModels.json configuration file and inserts a snippet template. This snippet includes the required properties such as model ID, name, endpoint URL, and token limits. You can then fill in the values for each model you want to add.
  • Manage provider groups: configure an existing provider group by selecting the configure action, for example to update the API key. You can also remove a provider group entirely by using the remove action.
  • Additional UI improvements: several usability improvements, such as keyboard access for toggling model visibility, context menu actions, and multi-select for bulk actions.
  • Language-model configuration file: model configurations are now stored in a dedicated chatLanguageModels.json file. Open this file directly by selecting the file icon in the top-right corner of the Language Models editor. This makes it easy to view, edit, or share your model configurations.
  • Model provider configuration UI: model providers can declare their configuration schema, and VS Code provides the UI for users to enter their configuration. See Chat Model Provider Configuration for details on this new proposed API. Existing model configurations from the GitHub Copilot Chat extension are automatically migrated.
  Language model configuration
  Settings: github.copilot.chat.implementAgent.model, inlineChat.defaultModel
  • Default model for plan implementation (Experimental): You can now configure a default language model for the implementation step of the Plan agent (github.copilot.chat.implementAgent.model). Leave the setting empty to use the default model. The model value should be a qualified model name in the format Model Name (vendor), for example GPT-5 (copilot) or Claude Sonnet 4.5 (copilot).
  • Default model for inline chat: By default, editor inline chat uses the default model of the selected vendor. This enables extensions to provide a model that's specifically tailored for inline chat scenarios. If you prefer to use a different model, you can configure this with the inlineChat.defaultModel setting. This setting lets you choose a consistent default language model for inline chat, so your preferred model is used automatically whenever you start an inline chat session, without needing to select it manually each time.
  • Specify language model for agent handoffs: Agent handoffs now support an optional model parameter that lets you specify which language model to use when the handoff executes. This enables you to control the model that is used for specific agent workflows directly from your .agent.md file. The model value should be a qualified model name in the format Model Name (vendor), for example GPT-5 (copilot) or Claude Sonnet 4.5 (copilot).
  Agent customization skill (Experimental)
  Setting: chat.agentCustomizationSkill.enabled
  A new agent-customization skill teaches the agent how to help you customize your AI coding experience. When you ask about creating custom agents, instructions, prompts, or skills, the agent automatically loads this skill to provide accurate guidance.
  The skill covers:
  • Custom Agents - Creating .agent.md files with frontmatter configuration for tools, models, and behavior
  • Custom Instructions - Writing .instructions.md files with applyTo patterns for context-specific guidance
  • Prompt Files - Building reusable .prompt.md templates for common tasks
  • Skills - Packaging domain expertise in SKILL.md files
  • Workspace Instructions - Setting up project-wide conventions in copilot-instructions.md and AGENTS.md
  Agent Extensibility
  This release adds Claude Agent support so you can leverage Anthropic's agent SDK directly, MCP Apps that render interactive visualizations in chat, and new provider capabilities are giving you more ways to extend what agents can do.
  Claude compatibility
  If you use both VS Code and Claude, you no longer need to maintain separate configuration files. VS Code now reads Claude configuration files directly, so your agents, skills, instructions, and hooks work across both tools without duplication.
  VS Code detects the following Claude file locations:
  • Instructions: CLAUDE.md files in your workspace root, .claude/CLAUDE.md, and ~/.claude/CLAUDE.md. VS Code also reads instruction files from the .claude/rules folder.
  • Agents: .md files in the .claude/agents folder, following the Claude sub-agents format.
  • Skills: Skill definitions in .claude/skills and ~/.claude/skills folders.
  • Hooks: Hook configurations in .claude/settings.json and ~/.claude/settings.json.
  This compatibility extends across instructions, agents, skills, and hooks so that teams using multiple AI tools can share a single set of configuration files.
  Agent orchestration
  Agent orchestration is a powerful pattern for building complex AI workflows where multiple specialized agents collaborate to achieve a common goal. Instead of relying on a single agent to handle everything, orchestration distributes work across purpose-built agents, each optimized for a specific role like planning, implementation, code review, or research.
  This approach provides several key benefits:
  • Context efficiency: Each subagent operates in its own dedicated context window, preventing context overflow
  • Specialization: Different agents can use different models optimized for their task
  • Parallel execution: Independent tasks can run in parallel across multiple subagents
  VS Code has all the building blocks for setting up your agent orchestration flow with custom agents, subagents, and extra control over how agents are invoked.
  The community has created excellent examples of agent orchestration systems that you can use directly or adapt to your needs:
  • Copilot Orchestra - A multi-agent system with a "Conductor" that orchestrates planning, implementation, and code review subagents through a complete development cycle
  • GitHub Copilot Atlas - An extended orchestration system with specialized agents like "Prometheus" for planning, "Oracle" for research, "Sisyphus" for implementation, and "Explorer" for rapid codebase discovery
  Claude Agent (Preview)
  This release, we are introducing Claude Agent support, now in preview. This gives you the power to delegate tasks to the Claude Agent SDK using the Claude models included in your GitHub Copilot subscription.
  This integration uses the official Claude Agent harness by Anthropic, which means it shares the same prompts, tools, and overall architecture as other Claude Agent implementations. You can learn more about the Claude Agent SDK in the Anthropic documentation.
  This integration is in active development and we plan to add more features and improvements over the coming months. In the meantime, we would love to hear your feedback on how you are using Claude Agents in VS Code and what features you would like to see next. Don't hesitate to provide feedback on GitHub!
  Anthropic models
  Settings: github.copilot.chat.anthropic.thinking.budgetTokens, github.copilot.chat.anthropic.toolSearchTool.enabled, github.copilot.chat.anthropic.contextEditing.enabled
  We've made several improvements to Anthropic model support in VS Code:
  • Messages API with interleaved thinking: Anthropic models now use the Messages API, which includes support for interleaved thinking. This enables Claude to reason between tool calls, providing more thoughtful and contextual responses during complex multi-step tasks. Configure the thinking budget with the github.copilot.chat.anthropic.thinking.budgetTokens setting, or set it to 0 to disable extended thinking entirely.
  • Tool search tool: We enabled the tool search tool to help Claude discover and select the most relevant tools for your task from a larger pool of available tools. This feature can be toggled with the github.copilot.chat.anthropic.toolSearchTool.enabled setting.
  • Context editing (Experimental): We added support for context editing to help manage longer conversations more efficiently. This feature clears tool results and thinking tokens from previous turns, helping to defer summarization and maintain more context in chat sessions. Try it out by enabling the github.copilot.chat.anthropic.contextEditing.enabled setting.
  Support for MCP Apps
  In this release VS Code has added support for MCP Apps. MCP Apps allow servers to display rich, interactive UI in the client.
  Apps are displayed automatically when servers return them. If you're an MCP server developer you can learn more about MCP Apps by checking out:
  • MCP Apps demo repository
  • MCP Apps SDK and examples
  • VS Code MCP documentation
  • MCP server development guide
  Support for custom registry base URLs for MCP packages
  VS Code now supports the registryBaseUrl property in MCP server manifest files. This enables organizations to deploy MCP servers from private or alternative package registries, such as internal Azure DevOps feeds or custom PyPI repositories.
  Agent Optimizations
  Smarter context, faster search, better results. With Copilot Memory, agents remember what matters across sessions. External indexing brings fast semantic search to non-GitHub workspaces. And agents can now read files outside your workspace when needed, with your permission.
  Copilot Memory (Preview)
  Setting: github.copilot.chat.copilotMemory.enabled
  If you find yourself repeatedly providing the same context to the AI, you can now use Copilot Memory to store and recall important information across sessions.
  With the new memory tool, your chat can now access and update Copilot Memory directly. This enables the agent to retrieve relevant context from your stored memories and save new learnings as you work. Enable the memory tool by setting github.copilot.chat.copilotMemory.enabled to true.
  The memory tool should recognize when to store a particular piece of information as a memory ("always ask clarifying questions when in doubt") and when to retrieve relevant memories to inform its responses.
  You can view and manage all your memories from GitHub's Copilot settings.
  External indexing for non-GitHub workspaces (Preview)
  Setting: github.copilot.chat.advanced.workspace.codeSearchExternalIngest.enabled
  Workspaces that are not hosted on GitHub can now be remotely indexed for faster code search when using agents. When you use #codebase in a non-GitHub workspace, VS Code builds an index of your codebase that enables quick semantic search, providing the same powerful code search capabilities that are available for GitHub-hosted repositories.
  The index is built on the first request and might take a few minutes depending on the repository size and your network connection. Subsequent requests are much faster, as they use the cached index. The index automatically updates when you modify and save files.
  We'll be rolling out external indexing gradually over the next few weeks. Note that any workspaces that are hosted on GitHub already support remote indexing and do not require a more expensive call to build up the index on first request.
  Read files outside workspace
  Agents can now read files and list directories outside your current workspace with your permission. Previously, access attempts were automatically denied. Now, when an agent needs to access external files or folders, VS Code prompts you to allow or deny the request.
  You can also allow access for the entire session to avoid repeated prompts for future reads under the same folder.
  Performance improvements
  This iteration, we've made numerous performance improvements:
  • Large chats: Long chat conversations should now feel smoother to open and scroll around in. We've also optimized how conversations are persisted to make them more reliable overall.
  • Parallel dependent tasks: When running tasks via agents, dependent tasks are now processed in parallel instead of sequentially. This can significantly improve build times for projects with multiple independent build steps. Check our microsoft/vscode repo to notice the difference!
  Agent Security and Trust
  Run agent commands with confidence. New terminal sandboxing restricts file and network access for agent-executed commands, auto-approval rules skip confirmation for safe operations, and improved presentation shows exactly what's running and why, so you're always in control.
  Terminal sandboxing (Experimental)
  Settings: chat.tools.terminal.sandbox.enabled, chat.tools.terminal.sandbox.linuxFileSystem, chat.tools.terminal.sandbox.macFileSystem, chat.tools.terminal.sandbox.network
  Agents have the same permissions as your user account. To help mitigate risks associated with terminal commands executed by agents, we have introduced experimental terminal sandboxing capabilities. Terminal sandboxing restricts file system access to only your workspace folder and also lets you restrict network access to trusted domains only.
  Note: terminal sandboxing is currently supported on macOS and Linux only. On Windows, the sandbox settings have no effect.
  To enable terminal sandboxing, set the chat.tools.terminal.sandbox.enabled setting to true.
  When sandboxing is enabled:
  • Commands have read and write access to the current working directory by default
  • Commands run without the standard confirmation dialog because they operate in a controlled environment
  • Network access is blocked for all domains by default
  Learn more about configuring terminal sandboxing in our documentation.
  Terminal tool lifecycle improvements
  Several changes were made in this release to help solve problems around incorrect background terminal behavior:
  • You can now manually push a terminal tool call to the background, freeing up the agent to continue with other work.
  • A new timeout property is required to be filled in by the agent when a call to the terminal tool is made, where 0 means no timeout. This gives an extra escape to return control back to the agent when something unexpected happens.
  • The new awaitTerminal tool gives the agent the ability to wait for background terminals to complete, this also requires the timeout property. Provided the model leverages this tool, the expectation is that it prevents echo "successful" and sleep n calls that were previously used to wait for background commands to finish.
  • The new killTerminal tool gives the agent the ability to kill background terminals to clean up after itself. This aims to prevent how the agent would sometimes kill processes to achieve the same thing in a roundabout way, for example when it wants to stop an old in-progress server command.
  • Several instruction changes around how the current working directory works since the active non-background terminal always persists the current working directory, whereas background terminals always start in the workspace directory.
  Terminal auto-approval
  Settings: chat.tools.terminal.enableAutoApprove
  The following commands are now auto approved by default when terminal auto approve is enabled:
  • Set-Location
  • dir
  • od
  • xxd - flags and a single input file
  • docker - All safe sub-commands
  • npm, yarn, pnpm - All safe sub-commands
  Terminal enhancements
  A smoother, more capable terminal. Terminal commands in chat now show richer details including syntax highlighting and working directory. Kitty keyboard protocol support improves key handling in terminal apps, and new options let you customize sticky scroll and use terminals in restricted workspaces.
  Selectively ignore sticky scroll
  Setting: terminal.integrated.stickyScroll.ignoredCommands
  Some commands previously appeared in sticky scroll when that behavior was undesirable, for example commands like clear. From this release, you can customize which commands are ignored, and it already includes some common agentic CLIs (that run in the normal buffer) such as copilot, claude, codex, and gemini.
  Removal of winpty support
  Support for winpty has been removed from node-pty, which means terminals will no longer work in Windows versions before Windows 10 version 1809 (Fall 2018). ConPTY is the modern mechanism for terminals so we recommend upgrading to a newer version of Windows 10 or move to Windows 11. You may be able to get terminals to work by setting "terminal.integrated.windowsUseConptyDll": true, but note that this is currently experimental.
  Allow terminals to be opened in restricted workspaces
  Setting: terminal.integrated.allowInUntrustedWorkspace
  When workspace trust is not granted, opening the terminal is blocked to protect the user from attacks where the shell may execute code such as by setting variables via an .env file. Security conscious users often configure their shells to prevent this from being a possibility, so there is a new opt-in setting that allows opening terminals in restricted workspaces.
  New VT features
  Setting: terminal.integrated.enableKittyKeyboardProtocol (Experimental)
  The Kitty keyboard protocol has been implemented and will be rolling out to stable this release. This feature aims to fix a bunch of limitations around how keystrokes are traditionally encoded, specifically:
  • Allows the terminal to encode more modifiers and multiple modifiers, not just alt and ctrl
  • Handle both press and release events as well as repeated pressed (holding a key down)
  • Disambiguates many keystrokes, such as Escape which normally sends the ESC (\x1b) sequence which also happens to be the start of all escape sequences.
  This requires the program running in the terminal to support the protocol and request to enable it when it runs. A big benefit you will see immediately is shift+enter should work in some agentic CLIs without the need to run something like /terminalSetup.
  Setting: terminal.integrated.enableWin32InputMode (Experimental)
  Similar to the above, there's an experimental version of the win32 input mode which accomplishes similar but is tuned specifically for Windows and its pseudoterminal backend ConPTY. This will remain off for this release, let us know if you have any problems with it.
  Other:
  • Independent control of bold and faint SGR properties (SGR 222, SGR 221). This sequence is rarely used, but it's unambiguous and can corrupt output when used, so we decided to support it.
  Coding and editor
  Small refinements that add up. Double-click to select bracket or string contents. Customize bracket matching colors. Scope snippets to specific files. Detect TypeScript shebangs correctly. These focused improvements make everyday editing just a bit smoother.
  Bracket matching foreground color
  You can now customize the text color of matching brackets using the new editorBracketMatch.foreground color theme token. Previously, you could only customize the background (editorBracketMatch.background) and border (editorBracketMatch.border) colors. The new color token lets you make matching brackets stand out more clearly by changing the actual bracket characters' color.
  The setting defaults to null, meaning brackets inherit their normal text color. Configure it in your settings.json under workbench.colorCustomizations.
  Select bracket and string content with double-click
  You can now double-click immediately after an opening bracket or immediately before a closing bracket to select all the content inside. This also works for strings - double-click right after an opening quote or right before a closing quote to select the string contents. This provides a quick way to select, copy, or replace the content within brackets or strings without manually positioning your cursor.
  Rename suggestions for TypeScript
  Rename suggestions for TypeScript now also work when typing over an existing declaration. In the following video the user changes the declaration let index = 0; into let chunkIndex = 0; by typing the new identifier name instead of using the rename refactoring. Next edit suggestions still proposes to rename index to chunkIndex using Shift+Tab.
  Improved ghost text visibility
  Inline suggestions (ghost text) now display a dotted underline when showing short suggestions of fewer than three continuous non-whitespace characters. This visual indicator makes it easier to distinguish ghost text from actual code in your editor. This is particularly useful when the suggestion is a single character like ) that might be confused with existing code.
  Snippet file patterns
  You can now control which files a snippet appears in using include and exclude glob patterns. Use this to restrict snippets to specific files or project contexts, preventing them from appearing in unrelated files.
  For example, to create a snippet that only appears in Travis CI configuration files:
  Patterns match the absolute file path if they contain a path separator, otherwise they match just the file name. Both include and exclude can be a single pattern or an array of patterns. Use exclude to prevent snippets from appearing in specific files, even when they would otherwise match the snippet's language scope.
  Improved shebang language detection
  VS Code now has improved shebang language detection support, particularly for files using /usr/bin/env with additional flags. Files with shebangs like #!/usr/bin/env -S deno -A are now correctly detected as TypeScript. This enables better language support for scripts written in TypeScript using runtimes like Deno or Bun, even without a .ts file extension.
  Workbench and productivity
  Test, debug, and ship without switching windows. A new integrated browser lets you preview and inspect localhost sites directly in VS Code, complete with DevTools and authentication support.
  Integrated browser (Preview)
  Settings: workbench.browser.openLocalhostLinks, simpleBrowser.useIntegratedBrowser, livePreview.useIntegratedBrowser
  VS Code has long included the Simple Browser for opening basic web pages, such as localhost sites during development. However, because it relied on iframes, there were several limitations: website authentication wasn't possible, and common sites like Google, GitHub, and Stack Overflow couldn't be opened.
  This release introduces a new integrated browser for VS Code desktop that overcomes these restrictions. You can now sign into websites and browse any page, just as you would in a regular browser.
  Highlights include:
  • Persistent data storage with configurable scope (global, workspace, or in-memory / ephemeral)
  • Add element to chat: select an element and send it to an agent for assistance
  • Fully-featured DevTools
  • Keyboard shortcuts
  • Find in page
  And more...
  To try it out, run the Browser: Open Integrated Browser command. If you'd like to use the integrated browser more broadly, you can enable workbench.browser.openLocalhostLinks to open localhost links directly in the new browser.
  You can also configure the integrated browser to replace the Simple Browser with the simpleBrowser.useIntegratedBrowser setting, or to be used by the Live Preview extension using the livePreview.useIntegratedBrowser setting.
  Restore editors on workspace open
  Setting: workbench.editor.restoreEditors
  Previously, VS Code would always restore all open editors when reopening a workspace. With the new workbench.editor.restoreEditors setting, you can control whether editors should restore when opening a workspace or not. When the setting is disabled, VS Code starts with a clean editor area instead of reopening the tabs from your previous session.
  Note: Dirty (unsaved) editors always restore regardless of this setting to prevent data loss.
  Advanced settings
  Setting: workbench.settings.alwaysShowAdvancedSettings
  You can now configure VS Code to always show advanced settings in the Settings editor without having to apply the @tag:advanced filter each time. Enable the workbench.settings.alwaysShowAdvancedSettings setting to have advanced settings visible by default.
  Import profiles via drag and drop
  You can now import a settings profile by dragging and dropping a .code-profile file onto the VS Code window. This provides a similar experience to dragging and dropping a .code-workspace file, making it easier to share and apply profiles.
  Output channel filter improvements
  The Output panel filter now supports negative patterns and multiple filters. Use ! to exclude specific lines from the output, for example !debug hides all lines containing "debug". You can also combine multiple patterns with commas for more precise filtering.
  Filter problems by source
  The Problems panel now supports filtering by the source or owner of diagnostics. This is useful when you want to focus on specific types of issues, such as build errors, while temporarily hiding diagnostics from other sources like spell checkers or linters. For example, type source:ts in the filter box to show only TypeScript diagnostics, or use !source:cSpell to hide all spell checker warnings.
  Extension editor shows configuration defaults
  The Feature Contributions tab in the extension editor now displays configuration defaults contributed by extensions. This makes it easier to see what default settings an extension provides, such as language-specific editor configurations.
  Include additional files in git worktrees (Experimental)
  Setting: git.worktreeIncludeFiles
  When using background agents, a git worktree is created in order to isolate the changes. With the new git.worktreeIncludeFiles setting, you can specify additional files or glob patterns that are copied to the worktree folder after the worktree is created. This i

Original source Report a problem

Release date: February 4, 2026

Update 1.109.1

The update addresses these security issues.

Update 1.109.2

The update addresses an issue with chat.

Update 1.109.3

The update addresses these issues and introduces several notable features:

• Message steering and queueing: send follow-up messages while a request is still running
• Agent hooks: run custom shell commands at key agent lifecycle points
• Claude compatibility: reuse your Claude configuration files directly in VS Code
• Use skills as slash commands: invoke agent skills on demand from chat

Update 1.109.4

The update addresses these issues.

Update 1.109.5

The update addresses these issues and adds these features to improve background agents:

• Support for slash commands, including prompt files, hooks, and skills
• The ability to rename background agent sessions
• Kitty keyboard support is now available to all users

Downloads

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

Welcome to the January 2026 release of Visual Studio Code

In this release, we are further evolving VS Code to make it the home for multi-agent development.

Highlights include:

• Chat UX - chat just feels better and snappier with faster streaming, improved reasoning results, and a revamped editor inline chat
• Agent Session Management - it's now easier to delegate tasks to agents across local, background, and cloud and jump in when needed
• Agent Customization - build your own workflows using agent orchestrations, and have consistent results with Agent Skills and organization-wide customizations
• Agent Extensibility - reuse your knowledge with Claude agent support and new Anthropic model capabilities, and enjoy rich chat interactions with MCP Apps
• Agent Optimizations - agents work smarter with Copilot Memory and experience faster code search with external indexing
• Agent Security & Trust - feel confident running terminal commands with sandboxing and effective auto-approval rules
• Workbench & productivity - test your apps without leaving the editor with the new integrated browser
• Terminal Enhancements - quality-of-life improvements to make your terminal experience smoother and more reliable
• Coding & Editor - several impactful improvements to make everyday coding smoother
• Extensions & API - new capabilities for extension authors to build richer experiences

Happy Coding!

Watch our VS Code 1.109 release highlights video to hear about these features!

Extensive detailed release notes follow, covering features such as Message steering and queueing, Anthropic models thinking tokens, Mermaid diagrams in chat responses, Ask Questions tool, Plan agent improvements, Context window details, Inline chat UX revamp, Model descriptions in the model picker, Terminal command output enhancements, Output streaming, Interactive input in embedded terminals, Delete all hidden terminals, New experimental themes, Agent Session Management improvements including switching and delegating between agent types, Agent status indicator, Subagents and Search subagent, Cloud agents enhancements, Background agents improvements, Agent sessions welcome page, Agent Customization with Agent hooks and skills as slash commands, Workspace setup with /init, Agent Skills general availability, Organization-wide instructions, Custom agent file locations, Control over custom agent invocation, Multiple model support for custom agents, Chat customization diagnostics, Language Models editor improvements, Language model configuration, Agent customization skill, Agent Extensibility with Claude compatibility and MCP Apps support, Agent Optimizations including Copilot Memory and external indexing, Agent Security and Trust with terminal sandboxing and auto-approval, Terminal enhancements including sticky scroll and keyboard protocol support, Coding and editor improvements like bracket matching and rename suggestions, Workbench and productivity features including integrated browser and editor restore options, Advanced settings, Import profiles via drag and drop, Output channel filter improvements, Filter problems by source, Extension editor configuration defaults, Experimental git worktree file inclusion, SCM view improvements, Git delete command, Blame editor decoration hover control, Accessibility improvements, Enterprise improvements, GitHub organization policy enforcement, Extensions and API updates including Quick Input Button APIs, Proposed APIs for Chat Model Provider Configuration and Chat prompt files API, Chat item controller API, Chat output renderer API updates, Portable mode detection, Engineering updates including DMG image for macOS, Windows 11 context menu integration, Redesigned installation layout for Windows, macOS update handling, Copilot extension deprecation, Codicons consumption from npm package, Notable fixes, and acknowledgments.

Original source Report a problem

These release notes cover the Insiders build of VS Code and continue to evolve as new features are added. To try the latest updates, download Insiders. To read these release notes online, go to code.visualstudio.com/updates.

You can still track our progress in the Commit log and our list of Closed issues.

These release notes were generated using GitHub Copilot and might contain inaccuracies.

Happy Coding!

January 11, 2026

• The terminal now supports the kitty keyboard protocol (CSI u), enabling more sophisticated keyboard input handling and providing access to previously unavailable key combinations.
• The terminal now supports win32-input-mode, improving keyboard handling compatibility with Windows console applications.
• The terminal now supports SGR 221 and 222 escape sequences, allowing independent control of bold and faint text attributes for more granular formatting control.
• Improved discoverability of archived chat sessions in the Chat view, making it easier to locate and access previously archived conversations.

January 8, 2026

• The terminal tool now supports a timeout parameter to control how long terminal commands run before timing out, preventing unnecessary polling commands.
• Updated the list of npm commands that are safe for automatic execution.
• The terminal suggest toolbar no longer shows the selection mode option when quick suggestions are disabled, reducing confusion.
• The terminal.integrated.suggest.quickSuggestions setting can now be configured in the Settings editor instead of requiring manual JSON editing.
• Added a workbench.mcp.startServer command to start a specific or all MCP servers to discover their tools.
• Exploration work on rich integrated web browser using WebContentsView or controlledframe to overcome limitations of the current iframe-based Simple Browser.
• A new proposed API enables extensions to show buttons inline after the input box in quick inputs, in addition to the title bar location.

January 7, 2026

• You can now import a chat session into the Chat view instead of only opening it in a new editor tab.
• Fixed an issue where auto approval information for the fetch tool was not visible when hovering over the tool call.
• Added built-in support for MCP Apps, enabling servers to provide custom UI for tool invocation.

December 28, 2025

• The quick input now supports overflow buttons, enabling secondary actions to be placed in an overflow menu.

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

Original source Report a problem

December 2025 (version 1.108)
Release date: January 08, 2026
Update 1.108.1: The update addresses these issues
Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap
Welcome to the December 2025 release of Visual Studio Code.
Traditionally, the month of December is a time where our team focuses on cleaning up GitHub issues and pull requests across our repositories. This year, we managed to reduce our open issues by nearly 6,000 and triaged over a thousand more.
In addition to our housekeeping efforts, we have also made several improvements and feature updates across various areas of VS Code.
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.

Agents
Agent Skills (Experimental)
Setting: chat.useAgentSkills
VS Code now supports Agent Skills, allowing you to teach the coding agent new capabilities and provide domain-specific knowledge. Agent Skills are folders of instructions, scripts, and resources that GitHub Copilot can load when relevant to perform specialized tasks.
Skills are stored in directories with a SKILL.md file that defines the skill's behavior. VS Code automatically detects skills from the .github/skills folder in your workspace (or .claude/skills/ for backwards compatibility). They are then loaded on-demand into the chat context when relevant for your request.
Enable support for Agent Skills by enabling the chat.useAgentSkills setting.
Learn more about creating and using skills in the Agent Skills documentation.

Improvements to Agent Sessions view
This iteration, we further improved the Agent Sessions view with several enhancements:
• Keyboard access support for actions such as archive, read state, opening a session
• Grouping of sessions based on state and age when showing side-by-side
• Provide information on changed files and associated PRs for a session
• Support for archiving multiple sessions at once from the new group sections
• General accessibility improvements

Note: chat.viewSessions.orientation no longer provides the auto option. Use sideBySide as alternative.

Chat
Chat picker is based on agent sessions
The Quick Pick for chat sessions is now based on the same information that drives the Agent Sessions view. You can access any previous chat session from there and perform actions like archiving, renaming or deletion.

Note: Agent sessions can also be accessed by typing agent in the Quick Open control (Ctrl+P).

Chat title improvements
The Chat view title control is now showing up, irrespective of how the Activity Bar is configured. Previously, it only showed up in the default Activity Bar configuration.
To quickly jump from one session to another, select the chat title to open the sessions Quick Pick and choose another session.

Open empty Chat on restart
Setting: chat.restoreLastPanelSession
From now on, previous chat sessions are not automatically restored when VS Code is restarted. Instead, an empty Chat view is shown where you can then access previous sessions from the Agent Sessions control.
Modify this behavior with the chat.restoreLastPanelSession setting.

Terminal tool auto approve default rules
Settings: chat.tools.terminal.enableAutoApprove ORG, chat.tools.terminal.autoApproveWorkspaceNpmScripts
The following commands are now auto approved by default when terminal auto approve is enabled (chat.tools.terminal.enableAutoApprove ORG):
• git ls-files
• git --no-pager
• git -C
• rg (excluding --pre and --hostname-bin)
• sed (excluding some args and usage patterns)
• Out-String
In addition, npm scripts run through npm, pnpm, or yarn are now auto approved by default when they are included within the package.json. We do this because using agents already requires Workspace Trust, and we protect agents from editing sensitive files like package.json. This can be disabled with chat.tools.terminal.autoApproveWorkspaceNpmScripts.
To improve transparency around auto approve, there is now an informational message when a rule was explicitly denied by either default or custom rules:

Add session and workspace rules for future terminal tool commands
The allowed commands or command line entries in the Allow dropdown now have options a corresponding action to allow them for the current session or for the workspace.

Terminal tool preventing adding to shell history
Setting: chat.tools.terminal.preventShellHistory
When shell integration is enabled and working, commands that are run by the terminal tool are no longer included in shell history for bash, zsh, pwsh and fish. The method this uses differs for each shell, for bash for example HISTCONTROL=ignorespace is set and a space is added to the start of the command being run.
If you prefer to keep terminal tool commands in the shell history, configure this with the chat.tools.terminal.preventShellHistory setting.

Accessibility
Streaming chat responses in Accessible View
The Accessible View now dynamically streams chat responses as they are generated. Previously, you needed to close and reopen the Accessible View to see updated content. Now, you can stay in the Accessible View and monitor output as it comes in, making it much easier to follow along with AI responses in real-time.

MCP server output excluded from Accessible View
To reduce noise, MCP (Model Context Protocol) server output is now excluded from the Accessible View by default. The standard chat output remains fully accessible, as it's presented in a text area that works well with screen readers.

Language ID variable in window title
A new ${activeEditorLanguageId} variable is now available for the window.title setting. This variable displays the language identifier of the currently active editor, which is useful for accessibility tools like Talon that need to determine the current programming language to enable appropriate voice commands.

Editor Experience
Import profile by drag and drop
You can now import a settings profile by dragging and dropping a .code-profile file into VS Code. This makes it easier to share profiles with teammates or quickly set up a new environment.
When you drop the file, the Profiles editor opens and lets you preview and import the profile. This provides a similar experience to dragging and dropping a .code-workspace file to open a workspace.

Copy breadcrumbs path
Setting: breadcrumbs.symbolPathSeparator
You can now copy the breadcrumbs path to the clipboard by using the Copy Breadcrumbs Path command. This is useful when you need to share the exact location of a symbol with your team or for documentation purposes.
The breadcrumbs.symbolPathSeparator setting enables you to customize the separator character used to join breadcrumb segments.

Go to Symbol in Workspace supports special characters in query
The Go to Symbol in Workspace (Ctrl+T) feature no longer incorrectly filters out all results when the search query contains a # character.
This fix enables language extensions like rust-analyzer to use # as a modifier in symbol searches. For example, in rust-analyzer, appending # to a query like main# searches for functions in current workspace only.

Code Editing
New snippet tranformations
There are two new snippet transformations available: snakecase and kebabcase. This is how you can use them:
For snake_case transformation:
${TM_FILENAME/(.*)/${1:/snakecase}/}
This transforms the filename to snake-case format. For example, from MyFileName.txt it makes my_file_name.txt. The kebab-case transformation would be my-file-name.txt.

Source Control
Git blame information settings
Settings: git.blame.ignoreWhitespace, git.blame.editorDecoration.disableHover
The new git.blame.ignoreWhitespace setting enables you to configure Git blame to ignore whitespace changes when determining which commit last modified a line. This is particularly useful when working with code that has been reformatted, as it helps you identify the commit that made the actual functional change rather than just whitespace adjustments.
Additionally, the git.blame.editorDecoration.disableHover setting lets you disable the hover tooltip that appears when you hover over a Git blame editor decoration. This can be useful if you prefer a cleaner editing experience and only want to see the inline blame annotations without the additional hover information.

Authoring commit messages using the editor
Some time ago we added the capability to use the full editor to author a commit message but the actions to commit or cancel were difficult to discover in the editor title toolbar. We improved the editor overlay control in the lower right-hand corner of the editor and moved these actions there to make them easier to use.

Worktrees in the Source Control Repositories view (Experimental)
Settings: scm.repositories.explorer, scm.repositories.selectionMode
This milestone, we have added a Worktrees node to the Source Control Repositories view. Under this node, you can see the list of the repository worktrees with an inline action to open the worktree in a new window. The context menu also contains an action to open the worktree in the current window, as well as an action to delete the worktree.
You can enable the experimental repository explorer by setting the scm.repositories.selectionMode and scm.repositories.explorer settings. 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.

Terminal
Terminal IntelliSense default UX rework
During the past two releases, we rolled out terminal IntelliSense to all VS Code Stable users. While much of the feedback was positive, there was a segment of users (mostly terminal power users) that did not like the feature breaking their muscle memory. After a lot of discussion, we decided to switch some defaults, improve discoverability and allow easier inline configuration of the feature.
The feature itself is still enabled by default, but instead of showing the control automatically when typing (quick suggestions and suggest on trigger characters), it now needs to be explicitly triggered via Ctrl+Space.
We also improved the "status bar" on the bottom. Previously, it showed insert on the left and Learn more/Configure on the right with their associated keybindings. We got feedback that it's not clear that these can be interacted with, so we now show icons on the right and no longer show the keybindings. The left action now allows rotating through the options for "selection mode", which determines how Tab and Enter react when it's brought up. There's a new eye icon on the right, which enables quick suggestions and suggest on trigger characters again.
Finally, to still make this powerful feature relatively discoverable without being overbearing, a hint shows when opening a terminal that explains how to show suggestions. The lifecycle of the hint is simplified and it's as easy as clicking "don't show" to get rid of it permanently, just like the similar feature in the editor.
Beyond this UX rework, these improvements were also done to terminal IntelliSense:
• We now show files with the executable bit on macOS/Linux
• Improved completions for npm and git
• Several fixes to the feature

Performance and stability improvements
The terminal saw several important performance and stability improvements this release:
• node-pty#831: On macOS and Linux, pasting more than 50 characters at once or having Copilot run a large command is no longer throttled and should apply essentially instantly, scaling similarly to other terminals with KBs/MBs of data. This also fixed a crash that could happen on macOS when doing the same thing.
• vscode#285031, vscode#285032, xterm.js#5548: Fixed several layout thrashing issues that could cause the editor to get laggy.
• vscode#239541: Fixed a crash that could occur when fonts such as CommitMono were configured in the terminal.

More comprehensive custom glyphs
The terminal's GPU accelerated renderer (on by default) has supported custom glyphs for some time for box drawing, block element, and a subset of powerline symbols. This means that you can see these characters without needing to configure a font and they also scale with line height, letter spacing, and should align with each other perfectly.
In this release, we expanded the number of characters supported to almost 800 by including the majority of custom glyphs supported by any other terminal. This includes ranges that are generally useful in a terminal, specifically these ranges:
• Box Drawing (U+2500 - U+257F)
• Block Elements (U+2580 - U+259F)
• Braille Patterns (U+2800 - U+28FF)
• Powerline Symbols (U+E0A0 - U+E0D4, Private Use Area)
• Progress Indicators (U+EE00 - U+EE0B, Private Use Area)
• Git Branch Symbols (U+F5D0 - U+F60D, Private Use Area)
• Symbols for Legacy Computing (U+1FB00 - U+1FBFF)
Here's a visual of the complete set of glyphs:

Improved rendering of curly underlines
VS Code has been able to parse and display colored and styled underlines for some time now, but the curly underline's rendering always left something to be desired. The curly underlines should now look very close to how they look in the editor.
You can try this out for yourself by running this command in bash:
echo -e '\x1b[4:3mCurly\x1b[0m \x1b[4:3m\x1b[58;5;1mRed\x1b[0m'

Dimensions visual overlay on resize
Inspired by a feature in ghostty, we added a brief overlay that shows the current terminal dimensions (columns x rows) when you resize the terminal. This is useful if you want to resize your terminal to a specific size for testing or other purposes.

New VT features
The terminal now supports the follow VT features/sequences:
• Synchronized output: can be used by applications to pause rendering and batch updates in the terminal, which is particularly useful to prevent tearing when rewriting the buffer.
◦ DECRQM (CSI ? 2026 $ p)
◦ BSU (CSI ? 2026 h)
◦ ESU (CSI ? 2026 l)
• XTVERSION (CSI > 0 q): allows applications to query details about the terminal, the response VS Code will give currently is the "xterm.js" and its version

Debug
Organize breakpoints by file
Setting: debug.breakpointsView.presentation
Breakpoints can now be shown as a tree, grouped by their file. Enable this by setting debug.breakpointsView.presentation to tree.

Testing
Navigate to uncovered regions
We've added navigation buttons to the test coverage toolbar that allow you to easily jump between regions of uncovered code. You can toggle the test coverage toolbar using the Test: Show Coverage Toolbar command in the Command Palette.

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:
• Change a pull request's base branch from the pull request description webview.
• Convert open pull requests to draft from the pull request description webview.
• Generate a pull request description for an existing PR, not just new ones.
Review the changelog for the 0.126.0 release of the extension to learn about everything in the release.

Extension Authoring
New Quick Pick properties for prompts and resource URIs
The Quick Pick API includes two new properties for creating interactive selection interfaces.
Use the prompt property on QuickPick to display persistent instructional text beneath the input box. The text remains visible while users type, which helps provide guidance or context.
Use the resourceUri property on QuickPickItem to automatically derive item properties from a resource URI. When provided, VS Code derives:
• The label from the file name (when set to an empty string)
• The description from the file path (when set to undefined or an empty string)
• The icon from the current file icon theme (when iconPath is set to ThemeIcon.File or ThemeIcon.Folder)
This is useful when building file or folder selection interfaces.

Engineering
Housekeeping
As part of our annual December housekeeping, we spent a majority of time cleaning up GitHub issues and pull requests across all our maintained repositories. This year, we managed to reduce our open issues by 5,951 and triaged another 1,203 issues.
By using improved triage tooling and deduplication processes, we were able to close a significant number of stale and resolved issues. This has left us with a more manageble project, enabling us to move forward and develop the features that have the most impact for our users. In our core VS Code repository alone, we closed 2,872 issues and triaged another 1,697!
In June of 2025, we also announced that Copilot had become Open Source! This meant that all related issues would also be filed in the microsoft/vscode repo, and that we had a backlog of issues remaining in microsoft/vscode-copilot-release to take care of. This month, we triaged every issue in the repository and closed 1,659 issues, leaving only 175 open to be migrated.
Below is a graph that shows how our core vscode repository has grown over the years, and how many issues our amazing community has contributed over time. We appreciate everyone who has contributed issues to our repositories over the years and continued to engage with us. Your feedback is what has made VS Code the product that it is today! 🚀

Authoring extensions in TypeScript (Experimental)
It is now possible to author VS Code extensions directly in TypeScript without requiring a build step. This works... but there is still a bit of adventure involved! Many aspects are still untested, such as how to write and run tests, how to publish extensions, and other workflow considerations.
Learn more about this experimental approach in this GitHub comment.

Notable fixes
• vscode#283356 - Fixed regression causing jumping around while scrolling past some chat output

Thank you
Contributions to vscode:
• @abhijit-chikane (Abhijit Chikane): fix: hover focus border cutting at the corners PR #259548
• @alievilshat (Ilshat Aliyev): Fixed wrong negation in the _shouldRenderHint logic. PR #242479
• @Andarist (Mateusz Burzyński): Simplify TestInstantiationService#stub overloads PR #282223
• @anki-code (Andy Kipp): Added Xonsh shell type PR #284044
• @aryla (Arttu Ylä-Outinen): Fix sticky scroll hover listeners piling up PR #260020
• @AviVahl (Avi Vahl): fix: ensure fallback to default system monospace font PR #282747
• @BartolHrg: fix copy with multiple cursors and empty selections PR #256083
• @Beace (Beace): fix: fix terminal webgl context memory leak PR #279579
• @bibaswan-bhawal (Bibaswan Bhawal): fix(extensions): allow extensionButton.prominentBackground to take effect PR #276788
• @chaitanyamedidar (Chaitanya Medidar): Fix Swipe to navigate setting missing description #281997 PR #282220
• @CyMad7001 (Cyril Madigan): #196344 - Fix installer hang issue PR #228233
• @daiyam (Baptiste Augrain): fix: correctly pass extension's id when version is also provided PR #279630
• @eidriahn (Adrian Luca): fix: fixes icons not showing when hovering quick pick checkboxes PR #285250
• @erezak (Erez Korn): Chat: hide Apply in Editor from Command Palette PR #283486
• @flying-sheep (Philipp A.): fix: set LANGUAGE for Git PR #285410
• @gjsjohnmurray (John Murray): Standardize the breadcrumb toggle option label (fix #257550) PR #284486
• @hickford (M Hickford): Reverse lines: apply to whole document when selection is single line PR #257031
• @irengrig (Irina Chernushina): Fix memory leak with installing cursor change position listener PR #267799
• @isksss (isksss): Update: Fixed so that MARK can be used in vue files etc. PR #283583
• @izolotarev (Igor): Fix color detection in hsl saturation PR #266720
• @jakebailey (Jake Bailey): Replace old-style TS modules with namespaces PR #282862
• @jcpetruzza (Daniel Gorin): debug: Fix UI freezing on "continue" with high number of threads PR #283635
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #281127
• @joeriddles (Joe Riddle): Add snakecase to snippets syntax PR #237110
• @josephxiao8 (Joseph Xiao): Expected Final Selection After Running Delete Duplicate Lines PR #234799
• @junhaoliao (Junhao Liao): Suppress unhandled errors in WordHighlighter's runDelayer triggers. PR #285887
• @kheif (Mehmet Ege Aydın): workbench: add commands to move editor to start and end PR #284999
• @kortin99 (Kortin Zhou): feat(snippets): add support for kebab-case in snippets tmLanguage syntax PR #222319
• @maynkxx (mayank choudhary): docs: update Twitter branding to X in README PR #280235
• @milanchahar (MILAN CHAHAR): Fix terminal icon picker placement PR #281275
• @mizdra (mizdra): Fix tests that failed in environments where XDG_DATA_HOME is set PR #285402
• @MohamedEmirHajji (Mohamed Emir HAJJI):
◦ Add more git log options to completions PR #282311
◦ Markdown preview: filter hidden elements from scroll sync (fix #281247) PR #282506
• @murataslan1 (Murat Aslan):
◦ fix: avoid jumpy scrolling when navigating next/prev problem PR #285634
◦ Fix: Replace terminal tabbed view lifecycle hack with Event.once PR #285657
◦ Fix: Replace terminal view lifecycle hack with Event.once PR #285661
• @NriotHrreion (Norcleeh): fix: Latest input is not stored to the history when sending message to a new chat PR #282633
• @odinGitGmail (odinsam): fix(debug): support C# stack trace format in debug console links PR #281536
• @przpl: fix(runSubagent): collect computed attachments PR #283750
• @rducom (Raphael DUCOM): Fix ReDoS in PowerShell prompt detection PR #279853
• @RedCMD (RedCMD):
◦ Add TS/JS Template surrounding brackets PR #255972
◦ Fix php indenting #248229 PR #258016
◦ Fix FormatOnSave when modificationsIfAvailable PR #283726
◦ Support # pragma folding markers in C PR #284927
• @remcohaszing (Remco Haszing): Fix editor edge clicking PR #262964
• @Riya-chandra (RIYA_CHANDRA): Show command descriptions as tooltips in Command Palette PR #284609
• @SalerSimo (Simone Salerno):
◦ Exclude terminal editors from recently closed editors history PR #282009
◦ Refactor virtual model creation logic in MoveLinesCommand PR #284785
• @SimonSiefke (Simon Siefke):
◦ fix: memory leak in terminal editor PR #279088
◦ fix: memory leak in terminal process PR #279167
◦ fix: memory leak in terminal process PR #279172
◦ fix: memory leak in accessibility signal PR #279242
◦ fix: memory leak in local process extension host PR #279351
◦ fix: memory leak in extension icon widget PR #280566
◦ fix: memory leak in markdown hover PR #280745
◦ fix: memory leak in debug session PR #281767
◦ fix: memory leak in status bar PR #282246
◦ fix: memory leak in ipc PR #282253
◦ fix: memory leak in chat list renderer PR #282560
◦ fix: memory leak in notebook code scrolling PR #283452
◦ fix: memory leak in terminal find widget PR #283466
◦ fix: memory leak in mainThreadLanguages PR #283498
◦ fix: memory leak in chat widget PR #284288
◦ fix: memory leak in terminal chat widget PR #284325
◦ fix: memory leak call stack widget PR #286246
• @sudip-kumar-prasad (Sudip Kumar Prasad): Fix: use codicon id for Command Prompt default profile icon PR #280967
• @tamuratak (Takashi Tamura):
◦ fix: ensure finishedEditing is called in ChatWidget PR #281763
◦ include uppercase -I in sed in-place option detection PR #284645
◦ Fix context handling in ChatWidget while re-editing PR #285099
• @ThanhNguyxn (Thanh Nguyen): fix: Panel doesn't close when maximized and center-aligned (fixes #281772) PR #281773
• @tharani-2006: Terminal: show dimensions overlay while resizing PR #284244
• @tt0mmy (Tommy): Fix duplicate description in terminal suggestion config PR #279730
• @yavanosta (Dmitry Guketlev):
◦ Fix backward selection when EditContext is off PR #273150
◦ InlineEditsView: remove redeclaration of textModel PR #281501
◦ SingleUpdatedNextEdit: Correctly apply insertion changes PR #281519

Contributions to vscode-copilot-chat:
• @AbdelrahmanAbouelenin (ababouelenin): Update system prompt for VSCModelB. PR #2727
• @bharatvansh (Ayush Singh): fix(byok): improve Gemini provider error handling and add tests PR #2686

Contributions to vscode-js-profile-visualizer:
• @xiaoxiangmoe (ZHAO Jin-Xiang): chore: remove useless package-lock.json files PR #216

Issue tracking
Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @tamuratak (Takashi Tamura)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.
If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem