Visual Studio Code Updates & Release Notes

Welcome to the 1.127 release of Visual Studio Code. This release brings agents that can build and test web apps in the browser, safer per-site browsing, and new ways to keep busy agent sessions organized.

• Browser tools for agents: Let agents open pages, take screenshots, and click through to validate their own work, now generally available.
• Per-site browser permissions: Grant pages access to the camera, location, devices, and more, with a prompt for each site.
• Agent sessions: Group related sessions and drag and drop to arrange a busy Agents window.
• Chat input banners: Act on failing CI checks and incoming pull request comments without leaving the conversation.
• Subagent credits: Hover over a subagent to see the cost of the work it handled.

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.

Agents window (Preview)

The Agents window is a dedicated companion window optimized for exploring, iterating on, and reviewing agent sessions across projects and machines. This release brings new ways to organize the sessions list and keep a busy list of sessions manageable.

Use groups to organize sessions

When you run several agent sessions at once, the sessions list can grow quickly and become hard to scan. You can now organize the sessions list into groups to keep related sessions together. Create your own custom groups, and collapse group headers to tidy up the list and focus on what matters. Each group also offers quick actions: you can start a new session directly in a group, or mark all of its sessions as done with one action.

Drag and drop in the sessions list

The sessions list now supports drag and drop to further organize your sessions:

• Reorder sessions by dragging them up or down
• Drag session group and workspace headers to rearrange the list
• Drag a session onto a group to add it to that group
• Drop a session onto the Pinned section to pin it
• Select multiple sessions to move them together as a block

Chat input banners

When a coding agent session has an open pull request, the Agents window displays a banner directly above the chat input, letting you act on failing checks and incoming feedback right where you're working. Each banner provides a single action to fix or view the issue without leaving your conversation:

• CI failures: When checks on the pull request fail, a banner shows how many checks failed (for example, "2 of 5 checks failed") with quick actions: Fix Checks starts an agent fix, and Reveal Checks opens the failing checks in the Changes view.
• Pull request comments: When new review comments come in, a banner shows the comment count with actions: Address Comments hands them to the agent, and Reveal Comments opens them in the editor.

Onboarding tours (Experimental)

Getting started with agents can be daunting if you're not sure what they can do for you. Onboarding tours are now available in the Agents window to help you get up to speed quickly. These guided walkthroughs highlight key capabilities and show you how to make the most of working with agents, helping you discover the best ways to delegate tasks and stay productive from day one. We're experimenting with these tours to find the most helpful way to introduce new users to the experience.

Editor gutter feedback when reviewing agent changes

When reviewing an agent's changes, pointing it at the exact code you want changed should be effortless. You can now leave feedback directly from the editor gutter: hovering over a line reveals an Add Feedback glyph in the gutter, and selecting it drops a comment on that line, making it quicker to direct an agent to a specific spot in the code. This release also brings a round of polish to the agent feedback experience, with refinements to the feedback input, hover behavior, and overall visual consistency.

Better pull request titles and descriptions from session context

Creating a pull request from the Agents window used to produce generic titles and descriptions that often needed manual editing. The Create Pull Request button now uses the session context to generate the pull request title and description, resulting in more accurate and descriptive pull requests that better reflect the work done in the session.

Multi-chat sessions

Multi-chat sessions let you run several chats within a single agent host Copilot session. This release builds on that foundation with the following improvements.

Close, reopen, and delete chats

Create new chats from the + New Chat button in the session header. Once more than one chat is open, a tab strip appears with a trailing + to add more. Closing a chat with the X on its tab hides it rather than discarding it—bring it back from the Conversations dropdown, where each chat has a checkbox to show or hide it. To permanently remove a chat, open its tab context menu and select Delete Chat.

Progress and changes across all chats

Previously, the session only reflected the active chat's activity, making it hard to tell whether peer chats were still working or what they had changed. Progress and file changes are now aggregated across all chats: the session shows as in-progress whenever any chat is working, each tab surfaces its own progress, and the session header Changes pill reflects the combined edits from every peer chat.

Fork a conversation into a peer chat

When you fork a conversation in a multi-chat session, the fork now creates a new peer chat in the same session instead of a brand-new top-level session. The forked chat inherits the conversation up to the fork point, runs independently from its siblings, and gets an auto-generated title. Single-chat and non-agent-host sessions keep the existing behavior of forking into a new session.

Session layout: Consistent pills in the session header

The row of actions under the session title now renders consistently as uniform, compact secondary button pills. A Workspace pill shows the workspace icon (cloud, folder, or worktree depending on the workspace kind) and label, with long names truncated. The Changes pill (N files +X -Y) reads and opens the session's default changeset, keeping its count and the multi-file diff it opens in agreement for both Copilot and agent-host providers.

Focus moves to the chat input when switching sessions

When you open a session in the Agents window, keyboard focus now lands in the chat input, ready for you to start typing immediately, even when the session has editors open or a Changes view that loads. Highlighting entries in the sessions list with the keyboard does not move focus until you actually open a session.

Responsive sessions sidebar (Experimental)

On a narrow window, showing the editor, side panel, and sessions sidebar at once leaves little room to work. When enabled, the Agents window automatically hides the sessions sidebar when the window is narrow and both the editor and side panel are open, and shows it again when there is room. It respects a manual close and suspends the behavior when multiple sessions are shown at once.

Troubleshoot agent behavior with /troubleshoot

The troubleshoot skill, invoked with the /troubleshoot command, helps diagnose chat issues by analyzing chat session logs and surfacing insights into the agent's behavior. Use it to investigate why custom instructions are ignored or why responses are slow. In this release, you can use /troubleshoot to diagnose agent host sessions, including local and remote sessions. In the Agents window, type /troubleshoot in the chat input followed by #session, select the session you want to troubleshoot, and add a question or description of the issue you're experiencing.

Cost management: Subagent credits

When an agent delegates work to a subagent, it can be difficult to know the cost of the delegated work. To make this more transparent, you can now hover over a subagent section in the chat response to see the AI credits used by that subagent.

Sandboxing for terminal commands on macOS and Linux

Approving every agent-invoked terminal command quickly becomes tedious. Starting with this release, we're rolling out sandboxing for terminal commands on macOS and Linux: commands run with network access blocked and filesystem access restricted, letting the agent work with fewer prompts. The agent only asks for approval when a command needs to elevate and run outside the sandbox. To learn more, see Agent sandboxing. You can turn this off via the Permissions drop-down.

Deprecation of the built-in Ollama provider

Model providers can contribute models for the VS Code chat experience via an extension. By using an extension, providers can give you faster support for new models and capabilities than a built-in provider could offer. Ollama now has an official VS Code extension, which is the recommended way to use local Ollama models in chat. As a result, the built-in Ollama provider is now deprecated. If you're using the built-in provider to run local models with Bring Your Own Key (BYOK), install the official extension and remove the built-in provider to continue using your Ollama models without interruption.

Integrated browser

The integrated browser now supports per-site permissions. This enables pages to use more web APIs, including:

• Geolocation
• Camera and microphone
• Sensors, such as accelerometer and gyroscope
• Clipboard
• Devices, such as Bluetooth, USB, serial, and HID

When a page requests a permission, VS Code prompts you to allow or deny the request, as you would expect in a traditional browser. Manage permissions for the current site from the Site Permissions browser menu item.

Agent tools are generally available

Browser tools let an agent open pages in the integrated browser, read content and console errors, take screenshots, and select, type, and navigate to verify its own work, all without an external MCP server. After several milestones in preview, browser tools are generally available and enabled by default. A big thank you to everyone who ran the preview, filed issues, and shared feedback. Your testing directly shaped the per-session tab isolation, the explicit page-sharing controls, and the permission model that ship in this release. Ask an agent to build and validate a web app, or follow the step-by-step Build and test web apps with browser agent tools guide to see the closed build-test-fix loop in action. For the full reference, see Browser tools for agents. Administrators can govern browser tools through enterprise policy: disable them entirely with the BrowserChatTools policy, or restrict which domains agent tools can reach with agent network filtering (ChatAgentNetworkFilter plus allow and deny domain lists). See Configure AI settings for your organization.

Enterprise

File-based delivery for managed Copilot settings

Administrators can now deliver managed GitHub Copilot settings from a JSON file on disk, in addition to the native MDM channels and the account-based enterprise settings file. This gives organizations a straightforward way to apply policies on machines that aren't enrolled in a device management solution, or where provisioning a file through existing tooling (such as a configuration management system or imaging pipeline) is simpler than authoring native MDM payloads. VS Code reads a managed-settings.json file from a well-known per-OS location. This file is honored only when MDM or account-based enterprise settings are not present.

Deprecated features and settings

None

Thank you

Contributions to vscode and node-pty with various fixes and improvements from community members.

Issue tracking

Contributions to issue tracking from community members.

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

Welcome to the 1.126 release of Visual Studio Code. This release brings clearer cost transparency, simpler model tuning, and safer browsing of unfamiliar code.

• Session-level cost: See the total cost of a chat session to spot expensive conversations.
• Multiple chats per session: Run several chats side by side in one agent host Copilot session.
• Workspace trust: Browse new folders safely in restricted mode.

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.

Cost management

Session-level cost information

You can now see the cost for an entire chat session, not just for individual turns. This gives you better transparency into which sessions consume the most credits, making it easier to spot expensive conversations and manage your usage over time.

Language models

Unified model customization picker

To simplify language model configuration, we have combined the context size and reasoning (thinking) effort controls into a single model customization picker. From one place, you can adjust both settings when tuning a model, instead of working with two separate dropdowns.

Simplified model hover

We cleaned up the model hover to make it easier to scan. It now shows a concise one-word descriptor of the model's capabilities and includes deep link buttons that take you directly to the relevant configuration.

Agents window (Preview)

The Agents window is a dedicated companion window optimized for exploring, iterating on, and reviewing agent sessions across projects and machines.

Multiple chats in an agent host Copilot session

Applies to: Copilot sessions running on an agent host.

The Agents window lets you run and manage multiple agent sessions side by side. In this release, a Copilot session started from an agent host can hold several chats at once. Because the chats share the same session and working context, you can keep more than one conversation going in the same workspace at the same time.

Say your primary chat is busy implementing a feature. Instead of waiting or interrupting it, select New Chat (+) in the session toolbar to open a second chat in the same session, then use it to review the changes so far, draft tests, or write the documentation. Both run at once, and each chat keeps its own conversation. You can switch between tabs and pick up right where you left off.

Chats are persisted and restored across a window reload. Step away and come back to every conversation in the session, not just the first one.

You can rename a chat directly in its tab to keep track of what each one is for, just like renaming a session from the session header:

• Double-click a tab, or select Rename from its context menu, to edit the title in place.
• Press Enter to commit the rename, or Escape to cancel. Selecting another tab while editing also cancels the edit and switches to that tab.

A chat's title is independent of the session title, so renaming the session does not overwrite a chat you renamed.

Agentic code feedback with agent host harnesses

In the Agents window, comments you leave on generated code are now stored on the agent host, so the agent can interact with your feedback by using server-side tools such as listComments and resolveComments. This works even when you disconnect the client, since the comments live on the server rather than in your local session.

The agent can also create the comments for you by using the addComment tool. When you run a review skill such as /code-review, it reviews your code and adds comments inline, which you can then accept or delete before submitting them to an agent to address.

Pull request review comments work the same way. You can accept the PR review comments and submit them to the agent, or ask the agent to resolve all PR comments. When you ask the agent to resolve PR comments that you haven't accepted yet, it first requests your permission to view them, and once you grant access, it addresses the PR review items.

Editor experience

Open new folders in Restricted Mode

Setting: security.workspace.trust.startupPrompt

Workspace Trust lets you decide whether your project folders can automatically run code, which adds a layer of security when you work with unfamiliar code.

Previously, opening a new folder immediately interrupted you with a dialog asking whether to trust the folder before you could look at its contents. Now, new folders open in Restricted Mode and only show the trust banner. This lets you browse the code safely first and trust the folder when you're ready.

This changes the default value of the security.workspace.trust.startupPrompt setting from once to never. To restore the previous behavior and be prompted the first time you open a folder, set the value back to once.

Removed trust parent from the Workspace Trust editor

The Workspace Trust editor previously showed a Trust Parent button next to the Trust button. Because it looked just like Trust but trusted the entire parent folder, it was easy to select by mistake and trust more folders than you intended.

To reduce that risk, the Trust Parent button is removed. You can still trust a parent folder by adding its path to the Trusted Folders & Workspaces list in the Workspace Trust editor.

Engineering

Agent Host Protocol (AHP)

As part of rearchitecting how agent sessions work in VS Code, we are adopting the Agent Host Protocol (AHP). AHP lets us connect and render the same agent session from multiple clients and VS Code windows at the same time.

This unlocks scenarios like seeing the same session in both a regular VS Code window and the Agents window. The work is ongoing, but you can already try it out in VS Code Insiders and we would welcome your feedback.

Website

VS Code blog

As the team has been writing more and more blog posts, in quick succession, we realized that our blogs section could use some love. Previously, when you open the blog section, you were directly taken to the last blog post, leaving previous posts often overlooked. We have now added a blog landing page that highlights the several recent posts.

And if you are looking for the full list of all blog posts, you can now find it in the blog archive.

VS Code documentation

We've restructured our documentation table of contents to make it more scannable and easier to navigate. All our agentic documentation is now grouped under a single "Agents" section, and anything related to editing code and configuring VS Code is grouped under "Editor".

Previously, the documentation for supported languages and specific extensions was individually listed in the table of contents. We have now moved them under "Languages and Runtimes" and "Extension Docs" respectively, so you can find all the information you need in one place.

Let us know what you think of the new structure by submitting feedback in the microsoft/vscode-docs repository.

Deprecated features and settings

Edit mode

We have deprecated the built-in Edit mode, and removed the chat.editMode.hidden setting. We recommend using Agent mode instead, which covers the same editing scenarios while also being able to run tasks and tools on your behalf. Alternatively, you can create a custom agent to mimic the Edit mode experience.

Users who have Agent mode disabled (chat.agent.enabled) by policy will still see the legacy Edit mode.

Thank you

Contributions to vscode:

• @bikeshgyawali (Bikesh): Add missing unit test coverage for prefixedUuid in uuid.ts PR #322146
• @Bryan2333 (BryanLiang): fix issue 300307 PR #322104
• @carlbrochu (Carl Brochu): Add SKU to enhance GH telemetry events PR #321046
• @cavalloJustinEmery (Justin Emery): fix: plugin skill files not accessible when connected to remote PR #309465
• @guomaggie: select correct subagent model PR #321061
• @mjbvz (Matt Bierner):
  • Update contribution names PR #321503
  • Fully switch normal npm run compile to use tsgo too PR #321646
  • Kill and restart esbuild instances during watch mode PR #321219
• @rfeltis (Ralph Feltis): Add telemetry for chat quota notification banners PR #321793
• @romalpani (Rohan Malpani): Update new chat in session tip text PR #321965
• @wszgrcy (chen): fix: registerToolDefinition loss tags PR #319922

Issue tracking

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @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

Follow us on LinkedIn, X, Bluesky

Release date: June 17, 2026

Update 1.125.1: The update addresses these issues.

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

Welcome to the 1.125 release of Visual Studio Code

This release brings a smarter integrated browser, more control over extension updates, and stronger enterprise management for Copilot.

• Install model providers: Discover and install extra models via the Marketplace.
• Integrated browser: Search the web and securely browse over remote connections without leaving VS Code.
• Configurable auto-update delay: Choose how long VS Code waits before installing extension updates.
• Copilot policies: Deliver managed Copilot settings through your existing device management tooling.

Happy Coding!

Agents

View your additional spend usage in VS Code

To make sure you stay ahead of overage charges, the Copilot status dashboard now shows the percentage of your additional Copilot budget that you've consumed, so you can adjust your usage before you hit your configured limit.

You can view detailed usage and manage your additional spend in the Copilot settings.

Language Models

Install model providers from the Language Models editor

Beyond Bring Your Own Key (BYOK) models, extensions can contribute their own model providers. Previously, to find such an extension, you needed to know the right tag (language-models) to search for in the Extensions view.

Now the Language Models editor has an Install Model Providers button that opens the Extensions view filtered to extensions that contribute model providers, making it easier to discover and install them. After you install a provider, its models appear in the model picker alongside any others you have configured.

To learn more, see the language models documentation.

Integrated Browser

Web search from address bar

Setting: workbench.browser.searchEngine

Look up information without leaving VS Code: type a query into the integrated browser's address bar and it runs against your configured search engine, the same way it would in a standalone browser. Use the workbench.browser.searchEngine setting to pick which search engine to use.

Browse over remote connections (Preview)

Setting: workbench.browser.enableRemoteProxy

When the integrated browser is opened in a remote workspace, web traffic over HTTP(S) can now be proxied via the remote connection. This lets you securely connect to any ports or services that are only accessible from the remote machine.

This is a preview feature, so you might encounter bugs. Enable the workbench.browser.enableRemoteProxy setting to try it out, and file any issues you encounter in the VS Code repository.

Better agentic interaction with forwarded ports

If you have forwarded a port in a remote workspace, previously agents could have difficulty opening the browser due to a potentially different port number.

Now, if an agent requests a port that has been forwarded (and the remote proxy is not enabled), the URL is rewritten and the agent is notified of the change.

Editor Experience

Extension auto-update setting

Setting: extensions.autoUpdate

This setting is managed at the organization level. Contact your administrator to change it.

You can enable or disable automatic extension updates with the extensions.autoUpdate setting. In this release, we simplified the setting to use on and off values. Previous values such as true, false, onlyEnabledExtensions, and delayed are migrated automatically.

When auto-update is enabled, VS Code updates only enabled extensions. Disabled extensions are no longer updated automatically. They update the next time you enable them.

Note: Administrators can centrally manage the extensions.autoUpdate and extensions.autoUpdateDelay settings with enterprise policies.

Configurable extension auto-update delay

Setting: extensions.autoUpdateDelay

This setting is managed at the organization level. Contact your administrator to change it.

To give you more control over when extension updates are installed, you can now configure a delay for automatic extension updates. This builds on the delayed extension auto-updates feature introduced in the previous release.

Use the extensions.autoUpdateDelay setting to configure the delay in hours. By default, VS Code waits two hours before installing extension updates. The delay only applies when auto-update is enabled.

Extension Authoring

Language Server Protocol

Extension authors who build language servers can now adopt the latest protocol features by updating to version 3.18 of the Language Server Protocol. The corresponding VS Code client and server packages are available as [email protected] and [email protected]. For the full list of protocol additions and breaking changes, see the vscode-languageserver-node changelog.

Enterprise

Native MDM delivery for managed Copilot settings

Administrators can now deliver managed GitHub Copilot settings through native device management (MDM) channels on Windows and macOS, in addition to the account-based enterprise settings file. This builds on the enterprise-managed Copilot plugin policies and lets organizations enforce Copilot configuration using their existing device management tooling, without depending on per-user sign-in to apply policy.

For developers, settings delivered through MDM appear as policy-enforced in VS Code and cannot be overridden locally. Future updates expand the set of supported policy keys across Copilot surfaces.

Deprecated features and settings

None

Thank you

Contributions to vscode:

• @arun-357 (Arunachalam Nachiappan)
  • Fix raw markdown shown in image carousel caption PR #320754
  • Fix image carousel showing UUID on hover in modal editor title PR #320739
  • Use a media icon for the Images Preview editor label PR #320951
• @dymaaaj7 (Dimitrije): Fix declaration order of File and Reference in CompletionItemKind PR #314958
• @g0w6y (ⳕⲛτⲉⲅⲥⲉⳏτⲟⲅ 🕵🏻): Validate redirect scheme and strip credentials on cross-origin redirects in MCP HTTP client PR #320347
• @guomaggie: Switch from Copilot Proxy to CAPI V3 PR #320472
• @kangarko (Matej): Add setting to open changed chat files in an editor instead of a diff PR #320948
• @lucaspar (Lucas Parzianello): Fixed typo in cli update PR #245751
• @merfanian (Mahdi Erfanian): Preserve image source provenance across chat reference API boundary PR #320624
• @RedCMD (RedCMD): fix: Restrict continue comment to whitespace separated slashes PR #321230
• @Tyriar (Daniel Imms): fix(terminal): track ligatures addon config for change detection PR #318992

Issue tracking

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @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

Update 1.124.1

The update addresses these issues.

Update 1.124.2

The update addresses these issues.

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

Welcome to the 1.124 release of Visual Studio Code. This release makes it faster to work across agent sessions and gives agents more autonomy to finish your tasks.

• Autopilot: Autopilot, enabled by default, is now smarter to determine when a task is truly done.
• Background sessions: Quickly send a request in the background and keep composing the next session.
• Session navigation: Search, jump, and step through agent sessions with the keyboard.
• Browser history: Revisit and search pages you've already opened in the integrated browser.

Happy Coding!

Agents window (Preview)

The Agents window is a dedicated companion window optimized for exploring, iterating on, and reviewing agent sessions across projects and machines. This release focuses on making it faster to move between sessions and on preserving your context across reloads.

Background send for new sessions

Previously, starting a new session meant waiting for it to load before you could compose the next one. You can now send a request in the background instead: press Alt+Enter (or hold Alt and select Send ) in the new session view.

The view resets immediately and keeps its state, such as the selected model and context, clearing only the query text, so you can keep queuing up requests. Each started session appears in the sessions list once it commits.

Sending a prompt with Enter still navigates into the new session as before.

Navigate between sessions

When you work across many agent sessions, being able to find and switch between them quickly matters. This release adds several keyboard-driven ways to move through your sessions, from a searchable picker to back and forward navigation and direct jumps by position.

• Sessions picker: Press Ctrl+R (Cmd+R on macOS) to open a Quick Pick that lists your sessions in two groups, recently opened and other sessions, with the active session pre-selected. Search across both the session title and its folder, then:
  • Press Enter to open the selected session.
  • Press Cmd/Ctrl+Enter to open it to the side.
  • Press Right Arrow to open it in the background while keeping the picker open.
• Go back and forward: Press Ctrl+Tab to go back and Ctrl+Shift+Tab to go forward through the sessions you have visited, in most-recently-visited order.
• Previous and Next session: The Go to Previous Session and Go to Next Session commands step through the visible sessions list in display order, respecting grouping, filtering, and collapsed sections, and clamp at the list edges. Use Alt+Up / Alt+Down (or Ctrl+PageUp / Ctrl+PageDown ; Cmd+Alt+Left / Cmd+Alt+Right on macOS).
• Focus a session by position: Press Ctrl+1 through Ctrl+9 (Cmd+1 to Cmd+9 on macOS) to focus the Nth visible session in the grid, left to right.

Restore sessions on reload

Reloading or reopening the Agents window no longer loses your layout. The previously visible sessions and their state are restored automatically, so you land back where you left off. This includes:

• The visible sessions grid: which sessions were open, their left-to-right order, the active session, and any sticky or pinned sessions.
• Per-session layout, including auxiliary bar visibility, the active view container, and the editors open in each session.
• Sessions list state, including the pinned and read status of each session.

Close all sessions

Similar to editor's Close All... commands, you can now close all your sessions in one step with the new Close All Sessions command. This is especially useful when you have many sessions open and want to quickly switch to a new session without having to close each session individually.

Use the keyboard shortcut Ctrl+K Ctrl+W (Cmd+K Cmd+W on macOS) while a session has focus, or access the command from the Command Palette.

Single-file diff in the Changes view (Preview)

Setting: sessions.changes.openSingleFileDiff

By default, selecting a file in the Changes view opens the multi-file diff editor. To open only the changes for that file, you had to press Alt and select the file (Open Changes).

To always open a focused single-file diff editor when you select a file in the Changes view, enable sessions.changes.openSingleFileDiff. This lets you concentrate on one change at a time without the distraction of other files in the multi-file diff. When the setting is enabled, the redundant Open Changes inline action is hidden.

Widen the editor with the side bar chevron

When you open a file inside the Agents window, a chevron toggle now appears in the editor title bar, to the right of the tabs. Select it to collapse the secondary side bar (auxiliary bar) and widen the editor, and select it again to bring the side bar back. The chevron direction reflects the current side bar visibility.

Autopilot (Preview)

Autopilot is one of the chat permission levels that allows agents to take initiative and act autonomously, without needing explicit user approval for each action.

Autopilot is enabled by default

Settings: chat.permissions.default, chat.tools.global.autoApprove

This setting is managed at the organization level. Contact your administrator to change it.

Autopilot is now enabled by default in VS Code. Organizations can still control the visibility and usage of Autopilot via the chat.tools.global.autoApprove setting.

You can configure your default permission level for new chats with chat.permissions.default. Change the current permission level at any time in the chat input box.

Advanced Autopilot

Setting: chat.autopilot.advanced.enabled

Knowing when an agent has truly finished a task is hard. Stop too early and the work is incomplete, loop too long and you waste time and tokens. Advanced Autopilot changes how Autopilot (Preview) decides when to keep iterating and when to finish, so you get more complete results without manually monitoring the loop.

Instead of relying on fixed rules, a small utility model reads a transcript of the chat and decides whether the task is done. The objective that Autopilot works towards is surfaced in a tooltip above the chat, so you can always see what it is trying to accomplish. To keep things bounded, Autopilot loops a maximum of three times before it stops.

Set chat.autopilot.advanced.enabled to true to try this out.

Editor Experience

Create folder when opening folder from simple file dialog

When you are opening a folder from the simple file dialog (files.simpleDialog.enable), you can now create a new folder directly from the dialog by typing the name of the folder you want to create and pressing Enter or selecting OK.

Integrated Browser

History

Setting: workbench.browser.maxHistoryEntries

The integrated browser now retains the history of visited pages. History items are surfaced as suggestions when typing in the URL bar, and can be managed using Ctrl+H from within a browser tab. The maximum number of history items to remember can be adjusted via workbench.browser.maxHistoryEntries.

Improved toolbar customizability

Previously, Add Element to Chat and Toggle Developer Tools were the only actions that could be made persistently visible in the right side of the browser toolbar.

Now, all actions that appear within the overflow menu can also be surfaced persistently by right-clicking on the toolbar area to the right of the URL input.

Faster agentic text entry

Previously, typing text and pressing Enter required two separate tool calls. Now, the typeInPage tool supports a submit parameter to allow agents to type text and press Enter in one tool call.

This reduces round-trips for common text-entry scenarios.

Enterprise

Enterprise-managed Copilot plugin policies (Experimental)

VS Code now reads policy from the same configuration file that already drives enterprise plugin standards for Copilot CLI, so a single policy definition applies to both clients. In the future, VS Code and the CLI will align further on policy management from this shared source.

Enterprise admins can now centrally control which chat plugins and plugin marketplaces are available to developers, instead of asking each developer to configure them locally.

Introduced in 1.123, three new policy-backed settings can be configured through the Copilot enterprise settings file or via existing MDM solutions:

• chat.plugins.enabledPlugins: an allowlist of plugin IDs that the organization explicitly enables or disables.
• chat.plugins.extraMarketplaces: additional plugin marketplaces the organization wants to make available.
• chat.plugins.strictMarketplaces: when enabled, only marketplaces supplied by policy are trusted.

Plugins that are blocked by policy remain visible but appear disabled. Marketplaces that are managed by policy are tagged as such in the marketplace picker.

Deprecated features and settings

None

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

• @1Burhanuddin (Burhanuddin Mundrawala): fix: correct typo occured -> occurred in parcelWatcher.ts comment PR #319721
• @ajasad25 (Asad Meeran): Fix issue reporter "Preview on GitHub" opening repo root instead of the new-issue form PR #319577
• @gjsjohnmurray (John Murray):
  • Improve messages about restart / reload after extension update (fix #297278) PR #307353
  • Reinstate symbol icon colors in quickpicks (fix #299650) PR #299753
• @guomaggie: Switch from Copilot Proxy to CAPI PR #318443
• @ishaq2321 (Muhammad Ishaq Khan):
  • debug: Log errors when loading stored breakpoints/watch expressions (#_319805) PR #319806
  • editor: Cache getComputedStyle result in shadowCaretRangeFromPoint (#_319803) PR #319804
• @KirtiRamchandani (Kirtikumar Anandrao Ramchandani): fix: surface missing Git LFS git errors PR #319973
• @maruthang (Maruthan G): fix(explorer): guard file-explorer scroll handler against transient tree-map desync (#_188365) PR #310833
• @mohanrajvenkatesan23-04 (Mohanraj Venkatesan): html-language-features: include JSDoc summary and tags in

Original source

Follow us on LinkedIn, X, Bluesky

Release date: June 3, 2026

Update 1.123.1: The update addresses these security issues.

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

Welcome to the 1.123 release of Visual Studio Code. This release improves how you work with agents and the integrated browser.

• Larger context windows: Support for 1M context windows for Anthropic and OpenAI models.
• Session sync: Automatically sync your chat sessions across machines and search your coding history.
• Agents window: Open multiple agent sessions side-by-side to compare or review work in parallel.
• Research agent: Run deep research on a topic and get a thorough, well-cited Markdown report.
• Integrated browser updates: Favorite pages for quick access and more options to capture browser screenshots.

Make sure to rewatch VS Code Live at Build 2026!

Happy Coding!

Agents

Session sync and chronicle

Setting: chat.sessionSync.enabled (managed at organization level)

Your chat sessions now sync automatically to your GitHub account, giving you a personal, searchable history of your work across machines and workspaces.

Each session captures the conversation, the files you touched, repository context (repo, branch, timestamps), and any pull requests, issues, or commits referenced along the way.

With the new chronicle commands (/chronicle) in chat, you can put that history to work:

• Ask natural-language questions about past sessions
• Generate standup reports
• Get personalized productivity tips
• Search your coding history by topic, file, or PR

To enable session sync, turn on chat.sessionSync.enabled (managed at organization level). You can view the status of session sync in the Copilot status dashboard in the VS Code Status Bar.

For more details, see the Session Sync and Chronicle documentation.

Retry network-dependent commands in the sandbox

Setting: chat.agent.sandbox.retryWithAllowNetworkRequests

When a terminal command run by a local agent requires access to domains not configured as allowed, the command is retried inside the sandbox with unrestricted network access, then falls back to unsandboxed execution if it fails. This allows network-dependent operations such as git fetch to finish while keeping filesystem protections.

Agents window (Preview)

The Agents window is a dedicated companion window optimized for exploring, iterating on, and reviewing agent sessions across projects and machines. This release focuses on letting you work with multiple sessions side by side.

Multiple open sessions

You can now have more than one session open at the same time in the Agents window. Open another session next to the active one by:

• Selecting Open to the Side in the context menu of a session in the sessions list.
• Dragging and dropping a session from the sessions list into the sessions view area.
• Holding Alt and selecting a session in the sessions list.

Even though multiple sessions can be visible at once, only one is active at any time. The Terminal, Files, and Changes views operate on the active session, so switching updates these views.

Pin session views to keep them from being replaced. Use maximize action to expand a session view across all open views.

For more details, see the Agents window documentation.

Research agent (Preview)

Note: The research agent is currently in preview and available only in Copilot CLI (local) sessions in Insiders.

The research agent runs deep research on a topic and produces a thorough, well-cited Markdown report by gathering and synthesizing information from your codebase, relevant GitHub repositories, and the web.

It is optimized for depth rather than speed and has read-only access. To run it, type /research followed by your topic in the chat input of a Copilot CLI (local) session.

For more details, see Run deep research with the research agent.

Language Models

1M context window for Anthropic and OpenAI models

VS Code now supports 1 million token context windows for compatible Anthropic and OpenAI models, enabling work with larger codebases and longer conversations without losing context. Available with models like Claude Opus 4.7 and GPT-5.5.

Note: Larger context windows may consume more tokens per interaction, increasing AI credits usage under usage-based billing.

Integrated Browser

Favorite pages

The address bar in the integrated browser is remodeled to allow entering URLs, favoriting pages, and easily accessing favorites and open tabs.

Add a page to favorites by selecting the star icon in the browser URL bar.

Selecting the URL bar shows your list of favorite pages and open tabs.

More ways to capture screenshots

Setting: workbench.browser.experimentalUserTools.enabled

The previous release introduced Add Screenshot to Chat, letting you attach a screenshot of the current browser viewport to chat as context.

This release adds:

• Add Area Screenshot to Chat: Take a screenshot of a selected rectangular area and add it as chat context.
• Add Full Page Screenshot to Chat (Experimental): Take a screenshot of the entire web page, beyond the viewport, and add it as chat context. Requires enabling workbench.browser.experimentalUserTools.enabled.

Editor Experience

Delayed extension auto-updates

VS Code now applies a two-hour delay before automatically updating extensions to a newly published version, adding protection against problematic or compromised releases.

You can still update any extension immediately using the Update button. While waiting, the extension's details view explains the delay and schedule.

Note: This delay does not apply to extensions from trusted publishers like Microsoft, GitHub, and OpenAI, which update immediately.

Thank you

Contributions to issue tracking:

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

Contributions to vscode:

• @aaronpowell (Aaron Powell): Add marketplace ref support for plugin marketplaces PR #317901
• @goingforstudying-ctrl: fix: add white-space: nowrap to browser-emulation-toolbar-label PR #318935
• @guomaggie: [Search Subagent] Handle context window limit exceeded error PR #316529
• @maruthang (Maruthan G): fix: combine URI flags to prevent Electron argument filtering on Windows PR #308150
• @oded-ist (Oded S): Fix read_cell_output incorrectly reporting all outputs as too large PR #318148
• @PenguinDOOM (Penguin): Fix BYOK invalid stateful marker retries PR #317292
• @rebornix (Peng Lyu): Add mobile multi-diff view PR #318081
• @SimonSiefke (Simon Siefke): fix: memory leak extension actions PR #315054, fix: memory leak in ipc.electron.ts PR #317846, fix: memory leak in search results PR #282309
• @SLdragon (rentu): feat: add languageDiagnosticsService option for nes/inline completion provider PR #317678
• @Tyriar (Daniel Imms): fix: remove awaits inside Promise.race in shell integration test PR #319068

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

Welcome to the 1.122 release of Visual Studio Code.

This release further enhances the agent experience and makes BYOK more flexible, while adding new capabilities for testing web apps across different devices.

• Air-gapped BYOK: Use your own language models, even when you're not connected.
• Browser device emulation: Test your website's responsiveness across different devices directly in the integrated browser.
• Rich issue reporting: Create rich VS Code issue reports, including screenshots and video recordings.

Happy Coding!

GitHub Copilot moves to usage based billing.

GitHub Copilot has moved to usage-based billing.

Under the new model, each interaction consumes AI credits, which are calculated based on token (input, output, and cached) cost and on the model used. Complex interactions and more capable models consume more credits, while lightweight models and simpler tasks use fewer. Learn more about how you can optimize your usage.

Updated Copilot status dashboard.

The Copilot status dashboard now reflects usage-based billing. You can view your AI credits consumption, so you can monitor your usage at a glance.

Model costs in the model picker.

The model picker now displays cost information to help you make informed model choices. Different models have different costs per token type, so choosing the right model for your task can help extend your usage.

You can view all available models, their capabilities, context sizes, and billing details in the Language Models editor. Open it from the model picker by selecting ⚙️, or run the Chat: Manage Language Models command from the Command Palette.

Agents Window (Preview).

The Agents window is a dedicated companion window optimized for exploring, iterating on, and reviewing agent sessions across projects, harnesses, and machines. We keep improving it and the updates for this release include:

• Session hover details: Hover over a session in the session list to see its details at a glance. The hover shows the session title with an icon indicating the harness used, along with the project, worktree, and files changed.
• Local VS Code harness (Insiders only): We're continuing to iterate on the ability to use the local harness in the Agents window, such as improvements to the custom agent picker. The availability of the local harness is an early, experimental feature available only in VS Code Insiders. To try it out, you can enable the sessions.chat.localAgent.enabled setting in Insiders.

You can open the Agents window in several ways, including the Open in Agents button in the VS Code title bar. To learn more about how it works and what you can do with it, visit the Agents window documentation. You can also check out our new VS Code Insiders podcast episode about how the Agents window fits into agent-first development workflows.

Your feedback continues to be a great help in shaping Agents. If you've already been using it and providing feedback, thank you! Please continue to file issues on GitHub or browse existing issues.

Richer OpenTelemetry signals for agents.

Local agent sessions now emit a canonical github.copilot.* attribute namespace to OpenTelemetry, matching the GitHub Copilot CLI OpenTelemetry conventions. New signals add repository context, agent type, structured tool parameters, and hook outcomes to each session.

For the full attribute reference, see Monitor agent usage with OpenTelemetry.

Sandboxing.

Setting: chat.agent.sandbox.enabled

This setting is managed at the organization level. Contact your administrator to change it.

Previously, when you ran commands with Bypass Approvals or Autopilot mode, they were first attempted in the sandbox. If the command failed with a non-zero exit code, it was automatically retried outside the sandbox. Since approvals were bypassed anyway, this did not provide a meaningful safety benefit and could make the behavior harder to reason about.

Based on feedback from Insiders users, terminal sandboxing now only applies when you use Default Approvals, where it provides a clearer balance between safety and usefulness.

Use BYOK without a GitHub sign in.

Previously, using your own language model API key in VS Code required signing in to GitHub. Now, Bring Your Own Key (BYOK) works without signing in, so you can use chat, tools, and MCP servers in air-gapped or restricted environments where GitHub sign-in isn't possible. This also enables fully offline workflows with local models like Ollama.

To get started, run Manage Language Models from the Command Palette and add a provider such as Anthropic, Azure, Gemini, OpenAI, Ollama, OpenRouter, or a custom endpoint. Once at least one BYOK model is configured, the Chat view becomes available and sign-in prompts are suppressed.

Built-in tools and any configured MCP servers continue to work. Requests go directly to your provider.

Note: Inline suggestions and next edit suggestions (NES) still require a GitHub sign-in. BYOK powers chat, tools, and MCP servers only.

Utility model notification.

Settings: chat.utilityModel, chat.utilitySmallModel

A few flows in VS Code, such as chat title generation, commit message generation, and feedback, use a smaller utility model that normally comes from your Copilot subscription. When you use BYOK while signed out, the default utility models are unreachable, so a notification in the chat input prompts you to point them at one of your BYOK models.

You have two options:

• Select Configure to open settings and pick a BYOK model for chat.utilityModel and chat.utilitySmallModel. This unlocks the full set of AI features using your own language model.
• Dismiss the notification if you only need to use chat. The utility-driven features remain inactive until you configure a model.

The notification hides automatically once you configure both utility settings, sign in to GitHub, or remove all BYOK models.

Custom Endpoint provider in Stable.

The Custom Endpoint provider lets you connect models that implement Chat Completions, Responses, or Messages APIs, so you can use chat with your own endpoint and API key. You can use it to connect to self-hosted, enterprise, or other compatible AI endpoints.

The Custom Endpoint provider is now available in VS Code Stable.

To learn how to set it up, see Add a custom endpoint model.

Manage models in Agents window.

You can now run the command Chat: Manage Language Models directly from the Agents window to configure the language models you want to use while working there.

To use BYOK models, you must use the Local agent provider which is enabled in VS Code Insiders with sessions.chat.localAgent.enabled. Model configuration is shared with the editor window, so changes you make in either place are reflected in both.

Granular BYOK provider group actions in Manage Language Models.

Managing BYOK providers often means making small updates, such as rotating an API key or renaming a provider group without opening and editing the full JSON configuration by hand.

In the Language Model editor, supported provider groups now expose targeted actions based on the provider schema: Update API Key, Add Model, Rename Group, and Delete. This makes common provider maintenance tasks faster while keeping you in the same flow.

Remote Development.

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

Highlights include:

• EOL for 32-bit ARM Linux hosts

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

Integrated browser.

Emulate devices.

The integrated browser now includes out-of-the-box support for device emulation including screen sizes, mobile / touch emulation, custom user-agents, and more. This is especially useful for web development and debugging, allowing you to quickly test your website's responsiveness and behavior across different devices directly from VS Code without needing to switch to a separate browser or use external tools.

To get started from a browser tab, select the Show Emulation Toolbar command from the overflow menu.

Agents can also trigger device emulation via Playwright code, for example to catch mobile responsiveness issues.

Add browser screenshot as chat context.

The new Add Screenshot to Chat feature lets you attach a screenshot of the current browser viewport to the chat as context. This is especially useful for UI-related tasks, such as debugging a layout issue.

Editor Experience.

Improved issue reporting flow.

Setting: issueReporter.wizard.enabled

To help us better understand and fix any problems you might run into in VS Code, we've improved the issue reporting flow with a new issue reporting wizard. The wizard guides you through creating high quality issues directly from VS Code, including adding relevant details, screenshots, and video recordings.

Enable the issueReporter.wizard.enabled setting to opt in to the new issue reporter.

Deprecated features and settings.

New deprecations in this release.

Upcoming deprecations.

Notable fixes.

Thank you.

Contributions to our issue tracking:

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

Contributions to vscode:

• @aaronpowell (Aaron Powell): Add marketplace ref support for plugin marketplaces PR #317901
• @dgercho (David Gerschcovsky): Enable to filter search within changed files of source tree PR #314790
• @oded-ist (Oded S): Fix read_cell_output incorrectly reporting all outputs as too large PR #318148
• @PenguinDOOM (Penguin): Fix BYOK invalid stateful marker retries PR #317292
• @SLdragon (rentu): feat: add languageDiagnosticsService option for nes/inline completion provider PR #317678

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

Welcome to the 1.121 release of Visual Studio Code

This release adds built-in Mermaid and HTML previews, streamlines terminal tool behavior for agents, and lets you run agent sessions on remote machines.

• Remote agents: Monitor and control agent sessions on a remote machine from the Agents window.
• Model configurability: Configure which models handle lightweight tasks like generating commit messages, titles, and more.
• Mermaid diagram preview: Render Mermaid diagrams directly in the Markdown preview and notebooks.
• HTML file preview: Preview local HTML files in the Integrated Browser without installing an extension.
• Terminal tool optimizations: Consume less resources and tokens with more output compression and background terminal cleanup.

Happy Coding!

Agents

Agents Window (Preview)

We continue improvement to the Agents window, which is the agent-driven companion window brought as a preview to VS Code Stable in our last release.

You can open the Agents window in several ways, including the Open in Agents button in the VS Code title bar. To learn more about how it works and what you can do with it, visit the Agents window documentation.

Your feedback continues to be a great help in shaping Agents. If you've already been using it and providing feedback, thank you! Please continue to file issues on GitHub or browse existing issues.

We're also continuing to work on the broader extension story in the Agents window, including what extension enablement unlocks and how various extensions should behave in this environment. Whether you'd like to ideate on new scenarios that take advantage of running agents across projects, or share feedback on how your existing extension behaves in the Agents window, we'd love to collaborate with you through GitHub issues.

Remote agents (Preview)

The Agents window has experimental support for running agent sessions on a remote machine that you own and can connect to via SSH or dev tunnels. Learn more about remote agent sessions in our documentation.

Connecting to a remote

You can connect the Agents window to a remote machine in two ways:

• SSH: pick from your existing ~/.ssh/config entries, or type a user@host.
• Dev Tunnels: pick from tunnels you've already created by running code tunnel on the target machine.

How it works

This feature is similar to, but not the same as, VS Code's remote development extensions. The Agents window connects to the remote, and either downloads and installs the VS Code CLI (SSH) or connects to the running CLI server via a dev tunnel that you started. It starts a lightweight process called the "agent host", which hosts a new agent loop built on the Copilot SDK.

An important point to note is that the remote agent host is a long-lived process. Running sessions continue to run on the remote even if your client disconnects, so you can close your laptop while the remote agent continues working.

Agent Host Protocol

The connection between the Agents window and the agent host is a new open protocol called the Agent Host Protocol (AHP). We're developing it in the open as a standalone spec.

The key design principle of AHP is that it enables coordination of agent sessions across multiple clients simultaneously. This is how it differs from other protocols like ACP. An agent host manages authoritative state, synchronizes it to every connected client, and sequences all mutations through pure reducers.

Because AHP is an open protocol, anyone can build a client that connects to the VS Code CLI's agent host, or build an AHP agent host that VS Code can connect to.

Agents observability with OpenTelemetry and Grafana

In collaboration with the Azure Managed Grafana team, there is now a prebuilt Azure Managed Grafana dashboard for the OpenTelemetry signals that agents in VS Code emit. Point VS Code at an OTel Collector that forwards to Azure Application Insights, then import the Azure Managed Grafana dashboard to visualize agent operations, token usage, chat sessions, tool calls, and per-model response time and time to first token (TTFT).

See Monitor AI coding agents with Grafana for the end-to-end setup, and Monitor agent usage with OpenTelemetry for enabling export from VS Code.

Claude agent Auto permission mode (Preview)

Setting: github.copilot.chat.claudeAgent.allowAutoPermissions

The Claude Agent now supports Auto mode, which lets Claude execute without permission prompts. A separate classifier request reviews actions before they run, blocking anything that escalates beyond your request, targets unrecognized infrastructure, or appears driven by hostile content Claude read. This is useful for long-running tasks where you want to reduce prompt fatigue while still keeping background safety checks in place.

To see the Auto option in the permission mode picker, enable github.copilot.chat.claudeAgent.allowAutoPermissions.

Note: If you want fully unattended execution with no safety checks ("YOLO mode"), enable github.copilot.chat.claudeAgent.allowDangerouslySkipPermissions to allow "Bypass all permissions" to show up.

Language Models

This release includes several improvements to how you configure and manage language models in VS Code, giving you more control over which models you use for different tasks within VS Code. Learn more about language models in our documentation.

Configure utility models

Setting: chat.utilityModel, chat.utilitySmallModel

VS Code uses utility models in the background for chat-related tasks such as generating titles, summaries, commit messages, rename suggestions, prompt categorization, and intent detection. By default, these tasks use utility models provided by GitHub Copilot.

You can use your own available models, including Bring Your Own Key (BYOK) models, for these flows:

• chat.utilityModel: Override the model used for general utility flows.
• chat.utilitySmallModel: Override the model used for fast, lightweight utility flows. A fast and inexpensive model is recommended for this setting.

Both settings use Default unless configured, which keeps the GitHub Copilot-provided utility models..

Custom Endpoint provider for BYOK (Insiders)

We now ship a new BYOK provider, the Custom Endpoint provider, that lets you plug any Chat Completions, Responses, or Messages-compatible endpoint into Copilot Chat from a single configuration. It replaces the legacy OpenAI Compatible (customoai) provider, which only supported Chat Completions and is now marked for deprecation.

When you add a model from this provider, you can pick which API family it belongs to (chat-completions, responses, or messages).

Note: The Custom Endpoint provider is currently in preview and only available in VS Code Insiders.

Integrated Browser

Quickly open HTML files in the Integrated Browser

Previously, previewing an HTML file required installing an extension, which is unnecessary friction for something so common. You can now easily open local HTML files via the Open in Integrated Browser option by right-clicking the file in the File Explorer, or right-clicking the editor tab when the file is already open. You can also select the Preview icon in the editor title bar when an HTML file is active.

Improved experience for adding elements to chat

We have reworked the element selection UI to enable richer functionality and theming support.

Select a range of elements

You can now click and drag to select a range of elements, making it easier to target shared container elements.

Attach elements from context menus

You can now right-click anywhere in a page to quickly attach elements to the chat.

Terminal

Agent-aware terminal commands

Command-line tools had no way to tell whether a terminal command was launched by a human or by VS Code's agent flow, which meant progress animations, interactive prompts, and verbose formatting could block or confuse agent sessions.

VS Code now sets a VSCODE_AGENT environment variable for agent-initiated terminal commands. CLIs can check this variable to switch to machine-readable output, suppress progress animations, or skip prompts that would otherwise block the session.

If you maintain scripts or CLIs that already adjust behavior for CI or other agents, you can use the same pattern for commands launched from Copilot Chat.

Running in background indicator for terminal tools

Previously, when a chat terminal command kept running after the tool call returned, the chat UI looked like the command had already finished, making it hard to tell that work was still in progress.

Tool invocations now show Running in background - Show while the terminal is still active. The Show action lets you reveal and focus the underlying terminal. Once the command finishes, the header returns to the normal completed state.

This makes it clearer when a command is still running in the background, especially for async runs or commands that were promoted to background execution after a timeout.

Cleanup of background agent terminals

Previously, when you had a long-running chat session that involved multiple terminal commands, you could accumulate background terminals after each command finished, filling up the terminal list with stale entries and consuming resources.

VS Code now automatically disposes background terminals created by the chat agent when their command completes, while still preserving the command output in the chat UI. If you reveal a background terminal with Show, it stays open so you can continue inspecting or interacting with it.

This keeps terminal lists clean and reduces resource usage over multi-turn sessions.

Broader compression for terminal tool output

Setting: chat.tools.compressOutput.enabled

Commands like pytest, jest, cargo test, tsc, and package installation workflows often produce large volumes of progress output before surfacing the important result, wasting tokens and making it harder for the model to find the relevant information.

Chat terminal tools now compress more kinds of verbose command output before sending it back to the model. The expanded coverage includes common test runners, build tools, linters, Docker commands, and package managers, so repetitive progress information and other low-value output are trimmed more often.

Long terminal runs are now easier for the model to interpret and less likely to spend tokens on boilerplate output.

Sensitive terminal prompts stay in the terminal

Password, passphrase, PIN, or verification-code prompts in terminal commands can pose a risk: the agent could accidentally capture or replay secrets if it tried to handle these prompts itself.

When a chat terminal command reaches a sensitive prompt, VS Code now intercepts it. In default permissions mode, chat shows a confirmation dialog that lets you focus the terminal to enter the secret directly there. In auto-approve flows, VS Code cancels the command and tells the model not to retry or request the secret.

This keeps credentials out of the chat context and prevents the agent from accidentally exposing or replaying sensitive input.

Editor

Quick suggestions default setting change

Copilot's inline suggestions always align with the selection of the suggest control. This is very useful, as you can quickly press Tab twice to accept both the suggestion and the ghost text from Copilot.

However, we've found that as you start to type, in many cases the suggest control pops up and selects the very first (alphabetical) available global symbol that starts with the typed character. This is rarely the text you'd actually type and it also results in Copilot giving you suggestions with that, incorrect, prefix, thus making the experience more noisy.

We've decided to change the default setting for quick suggestions (editor.quickSuggestions). If an inline completion provider is available (such as Copilot), then typing letters in the editor no longer automatically triggers the suggest control. In all other cases, the suggest control pops up as before. You can revert to the old behavior by configuring:

"editor.quickSuggestions": {
  "other": "on",
  "comments": "off",
  "strings": "off"
}

Languages

Mermaid diagrams in Markdown preview and Notebooks

We've merged Matt Bierner's Markdown Preview Mermaid Support extension into VS Code as a new built-in extension called Mermaid Markdown Features. This extension adds Mermaid diagram rendering to VS Code's built-in Markdown preview, to Markdown cells in notebooks, and to chats.

Mermaid diagrams can be created using a mermaid fenced code block in your Markdown:

flowchart LR
Sleep[Sleep] --> Wake{Awake?}
Wake -->|No| Sleep
Wake -->|Hungry| Snack[Get treat]
Wake -->|Not in in Sun?| Move[Move to sun]
Wake -->|Human is typing| Keyboard[Sleep on keyboard]
Snack --> Sleep
Move --> Sleep
Keyboard --> Sleep

Here's what the diagram looks like in the Markdown preview:

Rendered Mermaid diagrams also support panning and zooming, which makes larger diagrams easier to inspect without leaving the preview. You can also right-click a diagram to copy its Mermaid source.

YAML frontmatter in Markdown preview

Setting: markdown.preview.frontMatter

We've added options that control how YAML front matter is rendered in the Markdown preview. By default, instead of hiding the preamble, VS Code displays front matter as a table at the top of the preview.

You can use the markdown.preview.frontMatter setting to choose how front matter appears:

• table (default): Render front matter as a table.
• codeBlock: Render front matter as a YAML code block.
• hide: Hide front matter from the preview.

The rendered frontmatter also has a context menu entry for quickly opening this setting from the preview.

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

• @ba-work (Brock Alberry): outputMonitor: fix two false-positive families pausing the agent loop PR #315485
• @guomaggie: Return final answer text when snippet hydration errors PR #316094
• @kevin-m-kent: Experiment with terminal output deltas for repeated polls PR #315543
• @NikolaRHristov (Nikola Hristov): fix: restore protected modifier on relayCreationTimeoutMs in test helper PR #316049
• @SebTardif (Sebastien Tardif): Fix listener leak: move onDidChangeConfiguration out of onDidProgressStep callback PR #314636
• @SimonSiefke (Simon Siefke): fix: memory leak in lifeCycleMainService PR #315891
• @thernstig (Tobias Hernstig): fix: replace typescript.tsdk.desc with new js/ts.tsdk.path PR #315268
• @thirteenflt (yutingsun): change vsc promptD PR #316733
• @yavanosta (Dmitry Guketlev): Make appearedInsideViewport in InlineCompletionsModel reactive (#_289944) PR #289946

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

Welcome to the 1.120 release of Visual Studio Code. This release brings the Agents window to Stable, improves BYOK model visibility and control, and adds Markdown quality-of-life improvements and agent safety features. Here are the highlights for this release:

• Agents window in Stable: Work in an agents-first way across all your projects with the new Agents window.
• BYOK improvements: Track and optimize token usage and configure thinking effort for your BYOK models.
• Markdown improvements: Review Markdown content instead of syntax with Markdown preview for diffs.
• Command risk assessment: Assess the risk of terminal commands before they run.
• Token optimization: Reduce context window usage by compressing large terminal output.

Happy Coding!

Agents

Orchestrate tasks across projects with the Agents window (Preview)

While VS Code is already used by millions of developers for agentic coding, its editor layout is primarily optimized for single-task, single-workspace workflows. To enable our users (and ourselves!) to work with multiple agents across multiple projects, we created a new type of window: Agents.

The new Agents window is a companion to the editor you already know: purpose-built for agent-driven development, with a dedicated space to explore, iterate on, and review tasks across multiple projects, and seamlessly switch between them. And because VS Code is built for developer choice and flexibility, the Agents window lets you pick your agent harness, run agents on remote machines, and configure the environment the way you want it - color themes, keybindings, and extensions included.

The Agents window has been available as part of VS Code Insiders in our past few releases, and with this release, it's now available as a preview in VS Code Stable.

You can open the Agents window in several ways, including the "Open in Agents" button in the VS Code title bar. To learn more about how it works and what you can do with it, visit the Agents window documentation.

What's new?

If you've already been using the Agents window in Insiders, thank you! We've continued to act on your feedback, with the following improvements landing this week:

• Preferences persist across new sessions: Your last choices in dropdowns like agent harness and isolation mode are retained when you create new sessions.
• Discard changes more easily: You can discard edits directly from the Changes panel.
• Sync upstream changes in new sessions: A sync button on the Files panel lets you see upstream changes from the base branch and pull them in before the agent gets to work.
• More deterministic changes interactions: Actions in the Changes panel can complete more quickly as they're now deterministic.
• View all changes by default for completed sessions: When you open a session marked as done, you automatically get a view of the agent's full set of edits at a glance.
• Navigate between recent sessions: Use the arrow buttons in the top-left of the title bar to jump between recent sessions without leaving the window.
• Override settings per window: The Agents window now shares all of your VS Code settings, and you can override specific settings just for the Agents window when you want a different behavior there.

Your feedback continues to be a great help in shaping Agents. Please file issues on GitHub or browse existing issues.

Extensibility

Extensions that contribute only static content, such as themes, grammars, languages, and keybindings, activate in the Agents window automatically. We also tested the top 100 Marketplace extensions, and some of those activate as well when installed in your default VS Code profile.

For other extensions, you can opt them in by ID with the extensions.supportAgentsWindow setting. Any extension you enable this way needs to be installed in your default VS Code profile.

While we're still working on the broader extension story, we're looking to collaborate with extension authors on what extension enablement in the Agents window unlocks and how various extensions should behave in this environment. Whether you'd like to ideate on new scenarios that take advantage of running agents across projects, or share feedback on how your existing extension behaves in the Agents window, we'd love to collaborate with you through GitHub issues.

Discover Copilot CLI plugins automatically

Agent plugins installed with the GitHub Copilot CLI are picked up automatically by VS Code, so a single copilot plugin install covers both surfaces. Previously, you had to install the same plugin separately in VS Code or add its path to chat.plugins.paths.

Language models

With Bring Your Own Key (BYOK), you can use your own API keys from providers like Anthropic, OpenAI, and others to take advantage of your own billing or model hosting options. To learn more, see the BYOK documentation.

View BYOK model token usage

Managing a model's context window is key to getting good results and controlling costs. The model can lose track of important details from the conversation, and token usage can increase costs. This release brings better visibility into token usage for BYOK models, so you can keep an eye on the context window.

Previously, when chatting with a model you brought via your own API key (Anthropic, OpenAI, or other), the control always displayed 0% and a zero-token count because token accounting was only working for built-in models.

The context window control in the Chat view now shows accurate token usage and percent-full for BYOK models.

Configure thinking effort for BYOK reasoning models

Reasoning-capable language models allow you to configure their "thinking effort", which is a way to trade off between response quality and speed/cost. You can learn more in the thinking effort documentation.

In this release, you can now configure the thinking effort for BYOK reasoning models directly from the model picker in the Chat view. The selected effort is forwarded to the model on every request, letting you trade off latency and cost against answer quality.

Applies to: Bring-Your-Own-Key (BYOK) reasoning models served via OpenAI-compatible endpoints (OpenAI, xAI (Grok), OpenRouter, and custom OpenAI / Azure OpenAI deployments). Anthropic models already supported this; the control is now consistent across providers.

Model picker organized by provider

The model picker in the Chat view now groups models by their provider, making it easier to find the model you want when you have access to models from multiple sources. You can also search for models by name.

Recently used models now display the provider name in grey text alongside the model name, so you can quickly distinguish between similarly named models from different providers.

Tip: You can quickly access the models by typing /models in the chat input.

Chat

Terminal tool output compression (Preview)

Setting: chat.tools.compressOutput.enabled

Long terminal output from commands like git diff, ls -l, and npm install can consume a large share of the model's context window, which leaves less room for your code and the agent's reasoning.

When you enable the chat.tools.compressOutput.enabled setting, VS Code post-processes the output of these commands before sending it to the model. Large unchanged hunks in diffs are collapsed, lockfile and snapshot diffs are dropped, ls -l is reduced to entry names, and npm install progress bars, deprecation warnings, and audit summaries are stripped.

A short banner is prepended to any compressed output, so the model can see which filters fired and how to disable compression if it needs the raw text.

Risk assessment for terminal commands (Experimental)

Setting: chat.tools.riskAssessment.enabled

To help you decide quickly whether a command is worth a closer look, terminal command confirmations now include a risk badge with an AI-generated explanation of what the command does.

Each badge shows one of three levels along with a one-sentence summary tailored to the specific command:

• Safe (green): reads files or prints output without making changes.
• Caution (orange): modifies the workspace, installs packages, or sends data over the network.
• Review carefully (red): performs an action that may be difficult or impossible to undo, such as force-pushing to a remote or deleting files outside the workspace.

Plan mode control for Claude and Copilot CLI

Setting: chat.planWidget.inlineEditor.enabled

When you use plan mode with the Claude agent or the Copilot CLI, VS Code shows an inline plan control that lets you review and shape the plan before the agent starts executing. This release brings several improvements to that flow:

• Edit the plan inline: Editing the plan now happens in an inline editor inside the control instead of opening a separate editor tab, so you can iterate on the plan without losing context.
• Clearer feedback mode: When you're providing feedback on a plan, the control shows clearer indications that you're in feedback mode and shows the feedback you've added so far.
• Disable the inline editor: Opt out of the inline editing experience and fall back to editing in a regular editor tab by configuring the chat.planWidget.inlineEditor.enabled setting.

Languages

Markdown preview for diffs (Preview)

When you open a Markdown file from the Source Control view, you can view the diff using VS Code's rendered Markdown preview instead of the raw source.

This makes it much easier to spot meaningful changes, such as updated headings, new sections, modified images, or restructured lists, without having to mentally parse Markdown syntax line by line.

The diff Markdown preview supports both a side-by-side diff view and an inline view.

To try it, open a Markdown diff from Source Control (or any other diff editor) and use Reopen Editor With... to switch to the Markdown preview diff view. You can also open diffs in the Markdown preview by default with the workbench.diffEditorAssociations setting.

This feature is still a preview, so you might run into issues. We think it will be especially useful for reviewing documentation changes from agents or pull requests.

Markdown preview default changes

VS Code's built-in Markdown preview has been around for a while and a few of the original features aren't as necessary as they once were. This iteration we decided to disable two of these features by default:

• markdown.preview.doubleClickToSwitchToEditor: Double-clicking in the preview switches back to the source editor. Users often found it confusing as they wanted to use double click to make selections. We now have features like Reopen With that largely replace this functionality.
• markdown.preview.markEditorSelection: Marks the currently selected line in the editor. We think it's less useful for modern workflows.

You can re-enable these settings if you prefer the previous behavior.

HTML id support for Markdown path completions and validation

Our built-in Markdown path completions and link validation now recognize id attributes from HTML elements in Markdown files.

Links for these IDs are now suggested in completions and are also used for link validation.

Smart select for Markdown tables

Markdown tables now support basic smart selection. Use Expand Selection (Shift+Alt+Right) to grow the selection from a cell to its row and then to the full table, and Shrink Selection (Shift+Alt+Left) to step back down.

Proposed APIs

Custom editor diffs

The new customEditorDiffs proposed API lets custom editors render diffs with a dedicated diff UI. This is what powers the new Markdown preview in the diff view, and it opens up a much nicer compare experience where a textual diff of the underlying source isn't useful.

A custom editor provider can opt in by implementing one or both of the following on CustomReadonlyEditorProvider or CustomTextEditorProvider:

• resolveCustomEditorInlineDiff(documents, webviewPanel, token): render the diff in a single webview, with both the original and modified documents available to the extension.
• resolveCustomEditorSideBySideDiff(documents, webviewPanels, token): render the diff using two webviews, one for each side, with VS Code coordinating layout and scroll sync.

Combined with diffEditorPriority, extensions now have full control over whether their custom editor handles diffs and how those diffs are presented. See issue #138525 to follow along and provide feedback.

Separate custom editor priorities diffs and merges

Custom editor extensions can now set different default priorities for editing, diffing, and merging a file type. The customEditors contribution accepts two new optional fields, diffEditorPriority and mergeEditorPriority, alongside the existing priority.

The above contribution makes it so that opening a *.custom file uses the custom editor, but opening a diff from source control uses the normal text diff view.

This API is still proposed. Try it out and share feedback in issue #292379.

Document diff

The new documentDiff proposed API exposes VS Code's built-in diff algorithm to extensions via workspace.getTextDiff(original, modified, options?). It returns a streaming async iterable of line-level changes plus a complete promise with summary information (identical, may-be-incomplete, and optional move detection). Inner character-level ranges are included on each change.

This is especially useful for custom diff editors (see Custom editor diffs) so they can render exactly the same diffs as the built-in editor instead of shipping their own algorithm.

Track progress and provide feedback in issue #315174.

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:

• Uploading images to pull request comments through copy/paste and an upload button.
• More descriptive folder name when checkout out pull requests in a worktree.
• "githubIssues.issueBranchTitle" now supports the ${issueType} template variable.

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

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Notable fixes

• microsoft/vscode #314545 Include All-Interfaces links in integrated browser localhost targets

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

• @damonxue (DamonXue): Add File to Chat" does nothing when right-clicking a non-active editor tab PR #315197
• @davidwengier (David Wengier): Update repository and path for Razor repo PR #313011
• @Dmitriusan: Fix gitignore negation in child files not overriding parent/global rules PR #300613
• @EhabY (Ehab Younes): Detect dead connections via keepalive timeout PR #310131
• @JeffreyCA
  • Update Fig spec for Azure Developer CLI (azd) PR #308613
  • Integrated terminal - fix stale OSC 8 link hover tooltip issues PR #309539
• @kevin-m-kent
  • Emit parentRequestId on response.* events and from subagent loops PR #314309
  • Add X-Interaction-Type header and requestKind telemetry property for chat requests PR #312262
  • Ship stable symbol tool descriptions PR #315686
• @Larsjep (Lars Jeppesen): fixes https://github.com/microsoft/vscode/issues/291188 PR #314713
• @n-gist (n-gist): guarantee that return of TreeDataProvider.getChildren() is not mutated by vscode PR #306955
• @Pengkun-ZHU (pzhu): Pzhu/feature custom snooze time PR #298934
• @pranavvaid-ac
  • Update chat inline references after late anchor resolution PR #314281
  • Improve linked symbol anchors with tree-sitter fallback PR #314864
• @ruryu (ruryu): fix(agentHost): await dbClose to resolve flaky session database tests PR #313810
• @ShehabSherif0 (Shehab Sherif): Fix incorrect inspect property usage in scope detection PR #301472
• @SimonSiefke (Simon Siefke): fix: memory leak in utilityProcessWorkerMainService PR #294005
• @Tyriar (Daniel Imms)
  • Put ambiguous options into interface PR #313953
  • Remove unused export const PR #315244
• @yemohyleyemohyle: Yemohyle/response success gdpr blocks PR #315128
• @yogeshwaran-c (Yogeshwaran C): Strip codicons from terminal quickpick filter matching PR #313197

Contributions to vscode-pull-request-github:

• @MaxDNG (Maxime Guitet): Fix: Re-parent pulled-up directory children to ensure proper checkbox refresh PR #8679

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

Welcome to the 1.119 release of Visual Studio Code.

This release focuses on smoother agent interactions, enhanced observability, and more efficient trust and security controls.

• Agent-browser interaction: Let agents discover and ask for integrated browser access.
• Optimized token usage: Use a lightweight model to manage agent todo lists.
• OpenTelemetry tracing: Monitor agent sessions with OpenTelemetry.
• Trust and developer efficiency: Get less interrupted by requests for network access or temp folder writes.
• Markdown preview: Quickly switch between Markdown source and preview.

Happy Coding!

Agent experience

Sharing browser tabs with agents

When agents can access a live browser, they validate changes in real time and iterate faster. For web development, an agent can edit code, reload the page, and confirm the fix in a single turn. For design workflows, the agent can compare rendered output against your intent and refine layout or styling on the fly. Get started with using the integrated browser with agents in VS Code.

An agent does not automatically have access to the integrated browser. You need to explicitly share browser pages with the agent for it to interact with them. This helps keep sensitive data private.

In this release, we've added new ways to share browsers with an agent:

Attach browser tabs as context

Browser tabs can now be explicitly attached to the chat via typical entry points such as suggested context, context picker, and drag-and-drop actions.

When a browser tab is attached, it enters a sharing state where the agent can read and interact with the page. Use the sharing button in the browser to stop sharing when you're done.

Agents-initiated requests to share a page

Agents now have information about how many browser tabs you have open and are not shared. They can request to share an open tab when they need to interact with a page, and you can approve or deny the request in a prompt.

When an agent tries to open a new tab on the same domain as an existing, unshared tab, a prompt appears to ask if you want to reuse the existing tab. This aims to encourage tab reuse and reduce clutter.

Visual Studio Code Agents (Insiders)

Note: Visual Studio Code Agents is currently in preview and only available with VS Code Insiders.

Visual Studio Code Agents is a companion experience that ships with VS Code Insiders. It provides a focused, agent-native environment where you can run parallel sessions across repos and iterate on multi-step coding tasks. We first introduced VS Code Agents in 1.115 and continue to refine it based on user feedback.

Updates in this release include:

• Redesigned new session repo picker: When you start a new session, you can now easily switch between local folders, repos, or remote options.
• Sub-session improvements: Creating and managing sub-sessions continues to improve, with fixes in areas such as sub-session tabs and lifecycle handling.
• Web and mobile polish: We continue to iterate on the Agents web client introduced in 1.118 to align the browser experience with the desktop experience. This includes improvements to the mobile experience, so that you can create and manage sessions and their changes from the browser of your mobile device.
• Environment management and continuity: We continue investing in the connections between VS Code and Agents and evolving how the environment is managed. This continues to take shape in future releases.
• Progress UX: When an agent is working on a task, its progress is now more visible, with rotating progress messages and border animations for the chat input box.
• Developer joy: We're iterating on UX opportunities to spark developer joy, including a fun easter egg on the new session page. Enable sessions.developerJoy.enabled to see if you can spot it!

Your feedback helps us shape the Agents experience, so continue sharing it with us by filing issues in the vscode GitHub repo. You can also explore existing issues to see what others have reported and provide your feedback on specific topics.

OpenTelemetry tracing for agent sessions

Settings: github.copilot.chat.otel.enabled, github.copilot.chat.otel.otlpEndpoint

As agent sessions grow longer and more autonomous, understanding what the agent did, how long each step took, and where tokens were spent becomes essential for optimizing cost and debugging unexpected behavior. OpenTelemetry is the industry-standard observability framework.

Copilot Chat agent sessions, including the local agent, the Copilot CLI background agent, and the Claude agent, now emit OpenTelemetry traces, metrics, and events that follow the GenAI semantic conventions, so you can monitor agent behavior, latency, and token usage in any OTLP-compatible backend (for example, the Aspire Dashboard).

Each user request produces an invoke_agent root span (for example, invoke_agent claude) with nested chat, execute_tool, and execute_hook child spans. Subagent invocations are automatically parented to the calling agent's execute_tool span, giving you full visibility into the agent's work in a single connected trace. Spans report model and token usage, including cache read and cache creation breakdowns.

To try it out, enable github.copilot.chat.otel.enabled and point github.copilot.chat.otel.otlpEndpoint to your collector.

Learn how to monitor agent usage with OpenTelemetry in the VS Code documentation.

Chat experience

Show model details for Copilot CLI and Claude agent responses

Setting: github.copilot.chat.agent.modelDetails.enabled

Knowing which model handled a response and how it counts against your usage helps you stay in control of cost and quality.

Copilot CLI and Claude agent responses in the Chat view now show the model and its multiplier on each response. The badge appears live as each response completes, without needing to reload the window, and updates when you switch models mid-session.

When you use Auto model selection in Copilot CLI, the badge displays the actual model that was used (for example, Claude Sonnet 4.6) instead of auto. The resolved model is also preserved when the session is rebuilt from history.

The behavior is enabled by default. To turn off the badge, disable the github.copilot.chat.agent.modelDetails.enabled setting and reload the window.

Optimized token usage for managing todo lists (Experimental)

Setting: github.copilot.chat.agent.backgroundTodoAgent.enabled

Todo lists help an agent stay on track during complex, multi-step tasks by giving it an explicit record of what's been done and what comes next. However, every tool call the main model makes to update a todo list costs tokens, and those costs add up across long sessions.

By offloading todo list management to a lightweight background agent, the main model can focus on the actual task while a smaller model keeps progress tracking in sync. This reduces overall token usage without sacrificing the guidance that keeps the agent focused.

When this setting is enabled, the background agent monitors main agent activity and updates the todo list to reflect completed and in-progress work. The main agent will not have the todo tool available, thus saving token cost for the conversations.

Note: If the todo tool is manually added to the chat request (for example with #todo), or a custom agent specifies it in its tool list, the background agent is overridden and does not run.

This feature is disabled by default. To try it out, enable the github.copilot.chat.agent.backgroundTodoAgent.enabled setting.

Usage-based billing updates

GitHub Copilot is transitioning to usage-based billing starting June 1. In preparation, this release includes internal changes to the chat status dashboard, chat input notifications, and model picker to support displaying billing and credit information. These UI updates are not yet visible to users and will take effect when usage-based billing rolls out.

Trust and Security

Allow network access in agent sandboxes

Setting: chat.agent.sandbox.enabled

This setting is managed at the organization level. Contact your administrator to change it.

Agent sandboxing protects your system by restricting what agent tools can access, but strict network blocking can get in the way when agents need to install packages, call APIs, or run dev servers.

The chat.agent.sandbox.enabled setting now has an allowNetwork mode that keeps file system restrictions in place while removing network domain blocking, so you get sandbox protection without constant interruptions for network access.

When network access is allowed for the sandbox, the chat.agent.allowedNetworkDomains and chat.agent.deniedNetworkDomains settings are ignored. This setting is managed at the organization level. Contact your administrator to change it.

Learn more about agent sandboxing in the VS Code documentation.

Auto-approve writes to the temp folder for session-allowed commands

Setting: chat.tools.terminal.blockDetectedFileWrites

Frequent approval prompts for routine file writes can slow down agent workflows. When chat.tools.terminal.blockDetectedFileWrites is set to its default value of outsideWorkspace, terminal commands that write outside your workspace require approval, even if you selected Allow All Commands in Session.

Writes to the operating system temporary folder (/tmp on macOS and Linux, %TEMP% on Windows) are now exempt from this check when Allow All Commands in Session is active.

This means that common agent workflows that stage scratch files in the temp folder no longer interrupt the session, while writes to other locations outside the workspace still require confirmation.

Languages

Swap current editor to Markdown preview

We've made it easier to switch the current editor back and forth to the Markdown preview. VS Code has had this functionality for a while, but it was often overlooked. These new buttons and commands make it much more discoverable.

In a Markdown file, select this button in the toolbar or run the Markdown: Switch to Preview View command.

With the preview opened, you can select the Switch to Editor View button or command to swap back to the source code view.

Reorganized Markdown settings

To help you discover and manage settings for VS Code's built-in Markdown support, we've created a few basic groups for them in the Settings editor under Extensions > Markdown Language Features.

All setting IDs remain the same but now all the settings related to the built-in Markdown preview are listed under the Preview subsection.

Engineering

Finished migrating webviews to use CSS anchor positioning

VS Code's webviews now use anchor positioning to position themselves visually in the workbench. This improves performance and makes relayouts more responsive, especially if there are many active webviews. It also let us fix some tricky, long-standing bugs, such as webviews going out of position on web when the workbench was moved.

Here's a typical relayout call for a single webview before the switch to anchor based positioning:

Positioning the webview here was done using JS, which called getBoundingClientRect. This call ends up being relatively slow because it triggers browser style recalculations and relayouts.

By moving to anchor based positioning, the browser now handles positioning the webview for us based on the CSS.

Typechecking now uses TypeScript 7 for faster development iteration

Last iteration we moved VS Code's main watch task to use TypeScript 7. This iteration, we finished the migration to use TypeScript 7 for all built-in extensions and core code.

By migrating the Copilot extension to use TypeScript 7, we cut the typechecking time from 22 seconds to 4 seconds. These dramatic speedups enable both developers and agents to iterate more quickly in the VS Code codebase.

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 is managed at the organization level. Contact your administrator to change it. 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

Contributions to our issue tracking:

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

Contributions to vscode:

• @64johnlee (john lee): fix: enable text selection in elicitation dialog markdown content PR #313730
• @aanil677: Fix minor grammatical issues in README PR #312480
• @AshtonYoon (Ashton Yoon): markdown: fix scroll sync regressions introduced in #287050 PR #307763
• @iideprived (Herbert Smith): debug: default triggered breakpoint picker to first breakpoint PR #313453
• @Jah-yee (RoomWithOutRoof): fix: resolve NoChangeError tool name interpolation and typo PR #309709
• @maruthang (Maruthan G): webview: respect default localResourceRoots for custom editors PR #312492
• @OrenMe (Oren Me): Add structured preview for markdown customizations PR #312545
• @shaypet: Add compareBranch to TitleAndDescriptionProvider for enhanced PR context PR #312326
• @xAndreiLi (Andrei Li): feat(plugins): allow component paths within repository boundary PR #308776
• @yemohyleyemohyle
  • Yemohyle/add to telemetry PR #311837
  • Yemohyle/add to ext telemetrey PR #313159
• @yogeshwaran-c (Yogeshwaran C)
  • Add 'hint' and 'info' search keywords to editor.hover.enabled PR #313491
  • Add 'pane' search keyword to editor group settings PR #313490

Contributions to vscode-pull-request-github:

• @mohamedamara1 (Mohamed Amara): Display linked issue(s) from the PR Overview #5824 PR #6835

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

Welcome to the 1.118 release of Visual Studio Code.

This release expands where you can work with Copilot agents and makes them more efficient. Here are the highlights for this release:

• Remote control: Track and control your ongoing Copilot CLI sessions remotely from GitHub.com or mobile.
• Codebase search: Find the code you need with semantic search in any workspace and text search across GitHub repos and orgs.
• Dedicated context for skills: Isolate skill execution to keep your main chat focused and answers sharper.
• Chat session insights: Turn your chat history into standup reports, tips, and answers about past work.
• Enterprise control: Restrict AI feature access to organizations your admin trusts.
• Improved token efficiency: Get more out of every request with lower token usage.

Happy Coding!

Agent experience

Visual Studio Code Agents (Insiders)

Note: The Visual Studio Code Agents app is currently in preview and only available when installing VS Code Insiders.

The Visual Studio Code Agents app is a companion app that ships alongside VS Code Insiders. It provides a focused, agent-native environment where you can run parallel sessions across repos and iterate on multi-step coding tasks. We first introduced the Agents app in 1.115 and continue to refine it based on user feedback.

In this release, you can discover the Agents app directly from the VS Code Insiders title bar, making it easy to jump into an agent-powered workflow. We also published dedicated Agents documentation to help you get started.

Recent feature highlights include:

• Shared state across VS Code and Agents: The Agents app shares more state with VS Code Insiders for a smoother transition between the two. This includes authentication (on Windows), AI customizations, workspace trust, recent folders, and keyboard shortcuts.
• Claude agent: The Claude Agent is available in the Agents app, so that you can use it alongside other agents like Copilot CLI or Copilot Cloud for your coding tasks.
• Web client: Access the Agents experience from the browser at insiders.vscode.dev/agents, bringing the agent-native workflow to any machine where you have a Dev Tunnel running (via code-insiders tunnel). To get started, download VS Code Insiders and run code-insiders tunnel to set up a Dev Tunnel. You can then connect to it from the web.
• Background browsers: The integrated browser persists across sessions, so it no longer refreshes when you return to a session. This makes context switching smoother when using the integrated browser to preview changes while the agent works.
• Layout controls for changes: When the agent makes changes, you can open the diff view side-by-side with the Chat view or open it in a modal window to focus on the changes. Use the layout controls in the diff view toolbar to toggle between different display modes.
• Dynamic title bar entry points: Switch between VS Code Insiders and the Agents app with a single click. Select Open in Agents from the VS Code Insiders title bar to jump into the Agents app, or select Open in VS Code from the Agents title bar to return to the Insiders editor.

Your feedback helps us shape the Agents experience - please continue sharing it with us by filing issues on GitHub. You can also explore existing issues to see what others have reported and provide your feedback on specific topics.

Remote control for Copilot CLI sessions (Experimental)

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

Previously, to engage with a Copilot CLI session, you had to be at the machine where you started it. If the agent paused for an approval or hit a question while you were away from your desk, the work stalled until you returned. With remote control, you can monitor and steer your ongoing Copilot CLI sessions from anywhere, giving you more flexibility to keep work moving without being tied to your machine.

Remote control for Copilot CLI lets you check progress, respond to approvals, and steer work from another device (using GitHub.com or the GitHub mobile app), while your Copilot CLI session keeps running in the background.

To try remote control:

• Enable the github.copilot.chat.cli.remote.enabled setting.
• Enter /remote on in a Copilot CLI chat to get started.

You can always run /remote to view remote control status, or /remote off to disable remote control.

Synced session titles for Copilot CLI

The chat session title is used across different chat surfaces like the chat sessions list, the chat editor tab and header, and the Copilot CLI terminal interface to provide a consistent identifier for the session. Depending on where you renamed a Copilot CLI session, other chat surfaces could still show the old title.

VS Code adopts the Copilot SDK session title APIs as the source of truth and routes the sessions list and chat editor header through a single title resolver to keep the displayed title consistent across surfaces. The chat sessions list, the chat editor tab and header, and copilot --resume in the terminal now all stay in sync when you rename a session, regardless of where the rename originated.

Renames performed in the terminal from Copilot CLI are also picked up by VS Code the next time the session metadata is read.

Copilot added as a Git co-author by default

VS Code now enables Git AI co-authoring by default for chat and agent workflows. When Copilot makes changes to your files, Copilot is automatically added as a co-author on that commit.

You can change the default behavior using git.addAICoAuthor.

Codebase search and context

Semantic indexing of non-GitHub repositories rolled out to all users

When you ask Copilot a question like "where do we handle user authentication?", the agent has to translate your fuzzy intent into the exact files and symbols that matter. Plain text search only matches the literal words you typed, so it often misses the relevant code when your codebase uses different terminology. Semantic indexing lets agents search by meaning, surfacing files that use related terms like login, signIn, verifyCredentials, or OAuth token exchange, even if the word "authentication" never appears in the code. This gives the agent better grounding for answers and edits.

Semantic indexing is now available in all workspaces. Previously, this capability was limited to workspaces that use GitHub or ADO repositories.

The semantic index is built and maintained automatically. Workspaces that use a GitHub or ADO repository can typically use semantic search instantly, while other workspaces might require a few minutes to build up the initial index. You can also use the Build Codebase semantic index command to explicitly build the index for the current workspace.

Semantic search is one of the many tools Copilot uses to understand your workspace when answering questions and generating edits. Copilot will pick the best tools for the job, so you generally do not have to micromanage how it searches. Check out the How Copilot understands your workspace docs for more details on semantic search and the other tools that Copilot uses.

GitHub text search across repos or orgs

When the agent needs to look up an exact string, API name, or error message in code outside your current workspace, semantic search isn't always the right fit. You want a precise match across a known repository or your entire organization, not a fuzzy one.

To support this, Copilot now includes a built-in githubTextSearch agent tool that does a grep-style search through the code of a GitHub repository or an entire GitHub organization. This complements the existing githubRepo tool, which does semantic searches within a GitHub repo. Together, these tools give the agent a richer way to learn from codebases outside the one you are currently working on.

For more advanced GitHub features such as searching and managing issues or pull requests, consider using the GitHub MCP server.

Dedicated context for skills (Experimental)

Setting: github.copilot.chat.skillTool.enabled

When you use a skill that performs multi-step tool calls or pulls in large reference material, that auxiliary content can crowd your main chat context and degrade the quality of follow-up responses.

You can now run a skill in a dedicated subagent context that isolates its execution from the main conversation, so your primary context stays focused and skill responses remain higher quality.

To run a skill in a dedicated subagent context, set the context attribute in the SKILL.md frontmatter:

---
name: my-skill
description: My skill description
context: fork
---

This feature is experimental and requires the github.copilot.chat.skillTool.enabled setting to be enabled.

Workspace .mcp.json files and server deduplication

We've added support for workspace-level .mcp.json files to declare MCP servers, aligning with other tools such as the Copilot CLI.

Additionally, we've introduced behavior to deduplicate MCP servers that share the same name. By default, only the most-specific MCP server will be enabled, and enabling a server will disable other servers by the same name. You can control which MCP servers are enabled by searching @mcp @installed in the extensions view, or via the Chat: Open Customizations window.

Improving token efficiency

On April 27, GitHub announced that Copilot is moving to usage-based billing on June 1, 2026. To help you get the most value out of your plan, we have been working on several initiatives to improve token efficiency without hindering the quality of the agent. Most of the improvements described below are already in place. Where an opt-in setting is available, it is noted in the relevant section.

Prompt caching efficiency

Over the past several iterations, we have improved cache reuse across system prompts, tools, conversation history, and summarization, without changing how the agent behaves. In practice, this means repeated context is billed at a much lower token rate (for example, about 10x lower for Anthropic models), which helps reduce cost in longer, multi-turn agent workflows.

Strategic cache breakpoint placement.

We audited where cache breakpoints are set so they are used efficiently and placed at stable boundaries: end of system prompt, end of tools, end of the most recent tool turn, and conversation turn boundaries. As a result, once an agent session is underway, more than 93% of each request is reused from cache instead of being charged as new input.

A cache-stable system prompt and tools list.

A cached prefix is only as good as the bytes that precede it. We reviewed the system prompt and tool registration paths to remove sources of byte drift across requests. For example, the new chat.experimental.symbolTools.cacheStable registers vscode_renameSymbol and vscode_listCodeUsages with a static description instead of one that changes based on which languages are loaded. That way, when a language extension activates partway through a session, it no longer changes the request and resets the cache. We also re-ordered the tools list so deferred and non-deferred tools are grouped predictably, keeping the tools-array bytes identical across turns.

Cache-friendly background compaction.

As a session gets long, we summarize older turns in the background so the agent can keep working without running out of context. The model can still look up tool results and details from earlier turns when it needs them. These background summaries now reuse the same cached context as the main agent, making long, multi-turn sessions noticeably more efficient.

Last-two-messages breakpoint strategy.

In long agent sessions, older turns eventually fall out of the cacheable window. We now anchor cache breakpoints on System prompt, the Tools list, and the two most recent messages. This is currently available behind the github.copilot.chat.anthropic.cacheBreakpoints.lastTwoMessages setting.

Tool search tool

The tool search tool keeps requests lean by splitting the agent's toolset into two groups. A compact always-available core of ~30 tools, which covers ~88% of tool calls, are always included. The remaining tools are deferred: their schemas are not loaded into the model's context until the model explicitly requests them. When the agent needs a deferred capability, it calls tool_search, which runs a client-side, embedding-based semantic search and returns the most relevant matches on demand.

The result is a stable, cacheable prefix on every turn and a significantly smaller per-turn tool footprint, while the agent still has access to the full toolset.

The tool search tool is already enabled by default for Anthropic models (Claude Sonnet 4.5+ and Opus 4.5+), where we observed up to 20% in token savings. In this release, we are rolling it out to supported OpenAI models (GPT-5.4 and GPT-5.5) via the Responses API, with early Insiders results showing similar or better savings. To use the tool search tool with GPT models, enable the github.copilot.chat.responsesApi.toolSearchTool.enabled setting.

New tools for search and execution

This release brings two new specialized agentic tools: Search and Execution. Both are powered by small, purpose-built models that cost significantly less to run. After over a month of flighting, we are seeing promising results, with token savings of up to 20%.

Agentic search tool

The agentic search tool handles codebase exploration and context retrieval. When the main agent needs context, it describes what it's looking for in plain language, and the search tool takes over. The search tool then runs an independent process to search your workspace using grep, file search, semantic search, and file reading, then returns the most relevant results.

Under the hood, this tool is powered by a fine-tuned small language model, trained to run many searches in parallel across a minimal number of turns. This tight scope keeps latency and cost low without sacrificing retrieval quality.

Rollout continues over the coming month, bringing these savings to all Copilot Chat users.

Agentic execution tool

The agentic execution tool handles anything related to running terminal commands. When the agent has to run tests or check a build, it hands the task off to the execution tool, which runs the commands and reports back. To keep the scope tight, the execution tool can only run terminal commands, and it is capped at 10 terminal calls per invocation so it cannot loop indefinitely.

Terminal output tends to be long and noisy. Once the task is done, the execution tool filters that output down to what a coding agent actually needs and passes only the relevant parts back. Offloading this work from the main model to a smaller, faster one keeps verbose output from eating into your token usage.

Chat performance and history

WebSockets supported for OpenAI models

For OpenAI models that support it, chat requests now use WebSocket mode on the Responses API. Instead of opening a new HTTP request per turn, VS Code keeps a persistent WebSocket connection and sends only new input items along with the previous response ID. The server retains the conversation state, which reduces request size and latency on follow-up turns, particularly noticeable in agent workflows with many back-and-forth calls. Our measurements show that using WebSockets makes OpenAI models 12% faster.

WebSocket mode is used automatically when the selected model supports it, with no configuration required.

Chronicle (Experimental)

Setting: github.copilot.chat.localIndex.enabled

As you rely more on Copilot, your chat history becomes a valuable record of what you worked on, which files you touched, and which PRs and issues you referenced. But that history is hard to revisit: scrolling through past sessions to remember what you did yesterday or to prepare for a standup is slow, and there's no easy way to ask questions across sessions or learn from your own usage patterns.

Chronicle solves this by tracking your chat interactions in a local SQLite database. Every time you chat, it records session metadata (branch, repo, timestamps), conversation turns, files touched via tool calls, and external references (PRs, issues, commits), so you can search and summarize your coding activity on demand. Chronicle can also analyze your usage to give you personalized tips on how to improve your prompting and tool usage.

Chronicle exposes a few commands you can use in chat to query your session history and get insights about your coding activity:

• /chronicle:standup: Generates a standup report from the last 24 hours of coding sessions, grouped by feature/branch, with summaries, file lists, and PR links.
• /chronicle:tips: Analyzes 7 days of usage to give personalized tips on prompting, tool usage, and workflow.
• /chronicle [query]: Free-form natural language queries against session history (for example, "what files did I edit yesterday?").

This feature is experimental and requires the github.copilot.chat.localIndex.enabled setting to be enabled.

Trust and security

Approved account organizations policy

Enterprises can now gate chat and related AI feature activation on approved GitHub organization membership by using the ChatApprovedAccountOrganizations device policy.

This policy helps organizations apply GitHub account-based policy consistently across chat entry points. Chat features are not activated until (1) the user is signed into a GitHub account with membership in an approved organization and (2) the account-based policy has been resolved. This fail-closed behavior is useful for enterprises that configure account-based policies on GitHub.com and need eligibility enforced before chat is shown.

Learn more about enterprise policies.

Sandboxing default read permissions

Read access is no longer automatically enabled for all paths under the $HOME directory. This update strengthens sandbox isolation and ensures commands only access the files they explicitly need.

Before any command runs in sandbox, read permissions are added based on the executing command only and all other paths in the $HOME directory are denied read access. Accessing any arbitrary paths results in failure due to denied read permissions.

By default, workspace folders and the sandbox temporary folder (managing sandbox configuration at run time) are granted read access under $HOME dir.

Accessibility

Keyboard shortcut to focus terminal from question carousel

Setting: accessibility.verbosity.chatQuestionCarousel

When Copilot asks a question via the question carousel triggered by a terminal interaction, you can now press Alt+T to quickly return focus to the terminal. Previously, the only way to navigate back was by selecting the Focus Terminal button.

The button's aria label now also includes the keybinding hint to make it more discoverable for screen reader users. You can control whether navigation hints appear in the carousel's aria label with the accessibility.verbosity.chatQuestionCarousel setting.

Editor Experience

Optimized loading of large local resources in webviews

We've optimized how webviews load local resources to improve speed and reduce memory usage. This change benefits any extension that uses webviews or custom editors, as well as built-in VS Code features such as notebook rendering.

Webviews in VS Code use a service worker to load resources from the workspace or host file system. The service worker intercepts the request for the local file and then proxies it through VS Code's file system calls. This enables us to not only load resources from the disk but also from virtual file systems contributed by extensions.

Previously, for file system requests, VS Code would read the entire file into a buffer and then send it to the webview's service worker. This works for a few small JavaScript and image files, but not when you're loading 20 video files that are tens to hundreds of MB each.

Now, we stream the file contents to the service worker in chunks. This approach improves responsiveness and also reduces the amount of data that VS Code has to accumulate before handing it off to the browser engine.

We further optimized the streaming by adopting transferable streams. A file stream is created in the main VS Code renderer process and consumed directly by new Response(...) inside the webview's service worker. This bypasses what were previously multiple layers of postMessage calls.

Languages

TypeScript 7.0 Beta support

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

The TypeScript 7.0 beta continues to improve language features and also includes a number of editor quality-of-life improvements. We've also made it even easier to try out TS 7.0 and switch back and forth between it and the current stable TS 6.0 release.

To try TS 7.0 in VS Code, you only have to install the TypeScript Native preview extension.

Contributions to extensions

Chat Customizations Evaluation extension

We added a new extension, Chat Customizations Evaluations (extension ID ms-vscode.vscode-chat-customizations-evaluations) to help analyze and improve your chat customizations, like prompt files, custom agents, instructions, and skills. After analyzing a customization file, the extension generates diagnostics for issues it detects in the file and gives recommendations to improve it.

Open a prompt, agent, instructions, or skill definition file and select Analyze to evaluate it. After the diagnostics appear, use the customization evaluations fix skill to apply the recommended changes.

Remote Development

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

Dev Container lockfile for Features enabled by default

Setting: dev.containers.lockfile

We are enabling the lockfile devcontainer-lock.json by default. The lockfile records the Dev Container Feature version and checksum the first time a Feature is installed and pins the Feature to that particular version and checksum to improve resilience against supply chain attacks.

The editor shows a Code Lens on Dev Container Features in the devcontainer.json file when newer versions are available.

Dependabot support is also available for automatically submitting PRs to update the lockfile.

For more information, see Dev Container Feature Lockfile in the Dev Container specification.

Engineering

Faster development builds with TypeScript 7

VS Code's development watch task now uses TypeScript 7 for type checking. This dramatically reduces the time to build and fully type check our codebase.

Previously, typechecking the roughly 6,000 files in the main VS Code project took around 60 seconds. TypeScript 7 cuts this to around 10 seconds for a fresh build. From starting the watch build task to having VS Code and all of the built-in extensions built and fully typechecked now takes around 30 seconds.

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 is managed at the organization level. Contact your administrator to change it. 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

Contributions to our issue tracking:

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

Contributions to vscode:

• @AbhitejJohn (Abhitej John): Rename skillContentRead telemetry properties to use 'skill' prefix PR #311945
• @andrewkchan (Andrew Chan): aux window - fix setTimeout leak PR #311824
• @austinngan (Austin Ngan): Fix markdown preview scroll feedback loop (#_303765) PR #312237
• @fishcharlie (Charlie Fish): Chat: Show provider instance name for duplicate BYOK models in model picker PR #312028
• @kevin-m-kent: Add cache-stable mode for vscode_renameSymbol and vscode_listCodeUsages (experimental) PR #312568
• @maruthang (Maruthan G):
  • fix: handle heredoc/multiline commands in terminal tool execution PR #307960
  • fix(chat): enable scrollbar for height-capped code blocks in tool confirmations (#_283242) PR #310975
  • fix: clear parent change listener before disposeContext in ScopedContextKeyService PR #307593
• @mossgowild (moss): terminal tools: detect prompts on the last output line PR #311765
• @ssg (Sedat Kapanoğlu): add Turkish DOS (CP 857) encoding support PR #300114
• @Tyriar (Daniel Imms): Move skip shell handling to service and optimize PR #311892
• @winjo: Fix memory leak in AutoRepliesPtyServiceContribution on process dispose PR #312150
• @xingsy97 (xingsy97): contextkey: fix scanner returning '>=' instead of '>' for greater-than operator PR #307059
• @yogeshwaran-c (Yogeshwaran C):
  • fix: use setupDelayedHover for settings indicator hovers to support Ctrl+K I PR #304990
  • Show detail field for all debug console completion items PR #310379
• Contributions to vscode-pull-request-github:
• @Will-hxw (Will-hxw): fix(reviewManager): use pr.base.ref instead of pr.base.name in hasBranch call PR #8698

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

Welcome to the 1.117 release of Visual Studio Code. This release adds new capabilities for Copilot Enterprise and Business users and further improves the agent experience in VS Code. Here are the highlights for this release:

• BYOK for Business and Enterprise: Connect your own API keys for preferred or specialized models directly in VS Code chat.
• Incremental chat rendering: Experience more fluid streaming of chat responses.
• Terminal improvements: Launch Copilot CLI from any terminal profile.

Happy Coding!

Bring your own key for Copilot Business and Enterprise

Teams often need specific models for compliance, performance, or cost reasons, but switching between tools to use them slows developers down. Bring your own language model key (BYOK) lets Copilot Business and Enterprise users connect their own API keys for providers like OpenRouter, Ollama, Google, OpenAI, and more, so they can use those models directly in VS Code chat.

To enable BYOK, an administrator enables the Bring Your Own Language Model Key policy in the Copilot policy settings on GitHub.com. This gives administrators control over which model providers are available to their organization while keeping developers in their existing workflow.

After the policy is enabled, organization members can add models from built-in providers or install language model provider extensions.

Chat experience

Incremental rendering of chat responses (Experimental)

Chat responses feel more fluid and natural with incremental rendering, which streams content block-by-block with optional animations as tokens arrive. Instead of the default timer-based rendering, this experimental approach renders each block as it becomes ready, reducing the perceived wait time for longer responses.

Configure incremental response rendering with the following settings:

• chat.experimental.incrementalRendering.enabled: Enable or disable incremental response rendering with optional block-level animation when streaming chat responses. Default: true.
• chat.experimental.incrementalRendering.animationStyle: Configure the animation style for incremental response rendering. Options: none, fade, rise, blur, scale, slide, reveal. Default: fade.
• chat.experimental.incrementalRendering.buffering: Configure how content is buffered before rendering during incremental response rendering. Lower buffering levels render faster but may show incomplete sentences or partially-formed Markdown. Options: off, word, paragraph. Default: off.

Sort agent sessions by recent activity

When you accumulate many agent sessions, finding the right one can be difficult. The Agent Sessions view supports sorting sessions by when they were created or last updated, so you can quickly pick up where you left off.

System notifications for background terminal commands

When an agent runs a long-running terminal command in the background, it can be easy to lose track of its progress. These commands now surface as System notifications in the chat response, so you can monitor their status without switching to the terminal.

Agent experience

Visual Studio Code Agents (Insiders)

Note: The Visual Studio Code Agents app is currently in preview and only available when installing VS Code Insiders.

The Visual Studio Code Agents app is a companion app that ships alongside VS Code Insiders, providing a focused, agent-native environment where you can run parallel sessions across repos, review diffs inline, and iterate on multi-step coding tasks. Introduced in 1.115, the app continues to evolve based on feedback.

Updates in this release:

• Create sub-sessions: Select + in the session title to spawn a sub-session from the current session. This is handy for starting additional work in context, such as parallel research or a code review, without losing your place in the parent session.
• Inline change rendering: Improvements to how changes are rendered inline make it easier to scan and compare diffs when the agent edits your code.
• Update experience: Improvements to the update flow across operating systems make it smoother to stay on the latest version.
• Theming, chat response, and UX polish: Continued refinements to theming, session list and response rendering, and overall UX across the app.

As in previous releases, you can open the app via the same methods:

• Launch Visual Studio Code Agents - Insiders from your Start menu or Applications folder in the OS.
• Run Chat: Open Agents Application from the VS Code Insiders Command Palette.
• Select Try out the new Agents app from the VS Code Insiders welcome page.

Terminal

Launch Copilot CLI with a custom terminal profile

The Copilot CLI terminal profile can now be launched from the terminal panel, even when your default terminal profile is set to a non-default shell, such as fish on macOS or Linux, or Git Bash on Windows.

Previously, selecting GitHub Copilot CLI from the terminal profile picker in this configuration produced a No terminal profile options provided for id 'copilot-cli' error and the terminal failed to start.

Terminal title for agent CLIs

Agent CLIs like Copilot CLI, Claude Code, and Gemini CLI typically run as node processes, which meant the terminal title showed a generic node label. This made it hard to tell which agent was running in each terminal. The terminal now detects these agent CLIs as a distinct shell type and uses the OSC title sequence emitted by the CLI as the terminal title, so each terminal clearly identifies the agent it is hosting.

The improved detection covers Copilot CLI, Claude Code, and Gemini CLI on macOS, Linux, and Windows. Codex is not yet detected on macOS because it does not currently emit an OSC title sequence. This behavior is enabled by default and can be toggled with the terminal.integrated.tabs.allowAgentCliTitle setting.

Languages

TypeScript 6.0.3

This release includes the TypeScript 6.0.3 recovery release. This minor update fixes a few import bugs and regressions.

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

• @abadawi591 (abadawi-msft): Abadawi/send has image to router PR #308321
• @andysharman: fix: default session mode experiment not applying on first session PR #308905
• @bocan (Chris Funderburg): Fix crash on null entries in launch.json configurations array PR #308235
• @jamestut (James Nugraha): await openEditor in terminal editor split to prevent shadow tab PR #309167
• @maruthang (Maruthan G):
  • fix(tasks): add hover description for required property in taskDefinitions contribution schema (#_275670) PR #310764
  • fix(debug): identify instruction breakpoints by resolved address to allow removal when instructionReference changes (#_289678) PR #310763
  • fix(terminal-chat): dedupe terminal tool-session registrations to prevent listener leak (#_309906) PR #310740
  • fix(chat): guard renderWelcomeViewContentIfNeeded against undisposed input part (#_310356) PR #310822
  • fix: prevent listener leak from duplicate status IDs in language status (#_309042) PR #309159
  • fix(chat): cancel in-flight streaming tool invocations when response is cancelled (#_288701) PR #310979
• @matts1 (Matt): feat: Support switching to the main window. PR #306573
• @NikolaRHristov (Nikola Hristov): fix: make protected members public to resolve mangler build errors PR #310195
• @OscarPalafox (Oscar Palafox Verna): Consistent include pathing for new 2026 in theme-defaults PR #309880
• @RieBi (Sviatoslav Zubar): Additionaly to newest published version of package also show currently installed version PR #308569
• @yogeshwaran-c (Yogeshwaran C):
  • json: fix language model cache evicting at capacity instead of overflow PR #309176
  • Do not open debug view on first session start when openDebug is openOnDebugBreak PR #309133
  • testing: align right-click menu with hover bar on compressed result rows PR #309139
  • Adopt CodeAction type for built-in css server PR #310055

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

Welcome to the 1.116 release of Visual Studio Code

This release continues to make working with chat and agents more powerful and efficient. Here are some highlights of what's new:

• Agent Debug Logs: view logs from previous agent sessions to understand and debug agent interactions.
• Copilot CLI thinking effort: configure model thinking effort in Copilot CLI to balance response quality and latency.
• Terminal agent tools: interact with any terminal session from your agent sessions.
• GitHub Copilot built-in: start using AI without having to install the GitHub Copilot Chat extension.

Happy Coding!

Agent experience

Debug previous agent sessions

Setting: github.copilot.chat.agentDebugLog.fileLogging.enabled

The Agent Debug Log panel shows a chronological event log of agent interactions during a chat session, which is useful for understanding what happens when you send a prompt and to debug chat customizations.

You can now view the log for the current session as well as previous sessions, with logs persisted locally on disk. This enables you to review and debug past agent interactions even after the session has ended.

The setting to enable the Agent Debug Logs panel is now merged into the troubleshooting setting github.copilot.chat.agentDebugLog.fileLogging.enabled.

Learn more about the Agent Debug Logs panel in the documentation.

Configure thinking effort in Copilot CLI

Similar to local agent sessions, you can now configure the thinking effort for reasoning models in Copilot CLI sessions with the language model picker. Thinking effort controls how much reasoning the model applies to each request, which can help balance response quality and latency based on your needs.

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.

Learn more about thinking effort and reasoning in the documentation.

Customizations welcome page

The Chat Customizations dialog, available via the Chat: Open Customizations command or the gear icon in the Chat view, now has a welcome page that gives you an overview of all your agent customizations.

Creating customizations might be daunting at first, so you can now use the Customize Your Agent input on the welcome page to let VS Code draft customizations like agents, skills, and instructions based on a natural language description.

Learn more about customizing agents in the agent customization documentation.

Tool confirmation carousel (Experimental)

Setting: chat.tools.confirmationCarousel.enabled

To make approving or rejecting multiple tool calls more efficient, chat now shows a carousel control for tool confirmations. The carousel gives you a compact and navigable way to review and approve multiple tool calls in sequence without scrolling through the conversation.

This feature is experimental and controlled by the chat.tools.confirmationCarousel.enabled setting. It is enabled by default in VS Code Insiders and is gradually rolling out to Stable as we collect feedback.

Visual Studio Code Agents (Insiders)

Note: The Visual Studio Code Agents app is currently in preview and only available when installing VS Code Insiders.

In the last release, we shared the Visual Studio Code Agents app, a new preview companion app that ships alongside VS Code Insiders and is built for agent-native development.

Since introducing the app in 1.115, we've continued to iterate with features and fixes based on feedback, to deliver a great agent-first experience.

Some of the latest updates include:

• Reasoning level selection: as mentioned above, you can now configure thinking effort for reasoning models in Copilot CLI sessions.
• Plan mode handling: for CLI sessions involving planning, plan mode will automatically kick in.
• Files tab shown by default in Changes: the Files tab now shows by default in the Changes panel.
• Session response, theming, and rendering improvements: a range of refinements to response handling, visual consistency, and rendering performance.
• App name: We've renamed the app to Visual Studio Code Agents - Insiders.

We've added a new entry point to Try out the new Agents app from the VS Code welcome page:

You can also still open the app via the same methods as in 1.115:

• Launch Visual Studio Code Agents - Insiders from your Start menu or Applications folder in the OS.
• Run Chat: Open Agents Application from the Command Palette.

Terminal tools

Foreground terminal support for agent tools

The send_to_terminal and get_terminal_output agent tools now also work with foreground terminals and not just background terminals that were created by the agent. This means that the agent can read output from and send input to any terminal visible in the terminal panel, such as a running REPL or an interactive script.

Terminal input improvements

This release includes several improvements to the experience for terminal input in agent sessions:

• Detect terminal input: The LLM-based prompt-for-input detection is removed. Previously, every terminal output chunk triggered an extra LLM call to classify whether the terminal was waiting for input, which added latency and used extra tokens. The agent now handles terminal input directly via send_to_terminal and uses the question carousel to defer to you when needed.
• Progress messages: When the agent sends answers to the terminal, the progress message now shows which question is being answered, for example: Sending "my-project" to terminal (replying to: What is your project name?).
• Focus Terminal: When the agent needs terminal input, like when prompting for a password or an interactive installer like npm init, the question carousel now includes a Focus Terminal button. Select it to focus the relevant terminal and type your response directly. If you start typing in the terminal while the carousel is open, it automatically dismisses and informs the agent that you are handling the input directly.

Background terminal notifications enabled by default

Setting: chat.tools.terminal.backgroundNotifications

Background terminal notifications are now enabled by default. When the agent runs a command in a background terminal, it automatically receives notifications when the command completes, times out, or requires input. This enables the agent to respond more quickly and accurately without needing to poll for terminal output.

Chat UX

This release includes a few UX improvements to chat:

• Diffs in the top level: Code diffs now render directly in the chat conversation, so you can review proposed changes without switching context to a separate diff view.
• Rendering performance: Chat responses should now render faster, with added improvements including reduced layout thrashing and more efficient incremental updates during streaming. Also fixes an issue where rapid bursts of tool invocation updates cause brief hangs in the extension host.
• Chat send performance: Fixes an issue where chat message sending is blocked by loading chat customizations. The message now visually appears in the chat conversation immediately even if prompts are still loading.
• Subagent progress: The expanded view for subagent progress is now more visually distinct, making it easier to follow when a subagent is in progress.

Accessibility

Agents app accessibility

The Agents app, available in VS Code Insiders, now includes comprehensive accessibility support for keyboard and screen reader users.

• Accessibility help dialog: Press Alt+F1 (Option+F1 on macOS) while the chat input is focused to open the accessibility help dialog. It provides an overview of what the Agents app is, lists available views, and shows keybindings for navigating between them.

• Keyboard navigation commands: New keybindings let you quickly focus key views in the Agents app:

  • Focus Changes View (unassigned)
  • Focus Chat Customizations View (unassigned)
  • Focus Files Explorer View (unassigned)

  These keybindings are scoped to the Agents window and do not override their standard VS Code counterparts.

• Verbosity setting: The accessibility.verbosity.sessionsChat setting controls whether the chat input announces an ARIA hint about opening accessibility help. Disable it to suppress the announcement.

• ARIA labels and landmarks: The auxiliary bar is now marked as a complementary landmark with a descriptive label, workspace picker buttons have meaningful ARIA labels, and session list items include creation time context.

Screen reader instructions for keyboard shortcuts search results

When searching in the Keyboard Shortcuts editor, the screen reader now announces instructions for navigating to the search results. NVDA and other screen readers announce "Use Ctrl+Down Arrow to access the searched shortcut details", so you can quickly navigate to the results table. You can disable this announcement with the accessibility.verbosity.keyboardShortcuts setting.

Integrated browser

The integrated browser is now easier to access thanks to two new entry points:

• The View menu, under View > Browser
• The keyboard shortcut Ctrl+Alt+/

These actions open the integrated browser if no tabs are open, or let you quickly see and jump to existing tabs.

These new entry points are in addition to the previously existing ones:

• The Browser: Open Integrated Browser command
• Link clicks to localhost sites (workbench.browser.openLocalhostLinks)
• The title bar icon (workbench.browser.showInTitleBar)
• Ask an agent to open or interact with the browser (workbench.browser.enableChatTools This setting is managed at the organization level. Contact your administrator to change it.)

Languages

JS/TS Chat Features extension (Preview)

Setting: jsts-chat-features.skills.enabled

The new builtin JS/TS Chat Features extension enhances Copilot's skills to work with TypeScript and JavaScript. For this first release, the extension contributes skills for setting up modern TypeScript projects. We plan to enhance and expand its functionality in a future release.

To try these skills today, enable the jsts-chat-features.skills.enabled setting.

Engineering

GitHub Copilot is now built-in

GitHub Copilot Chat is now a built-in extension in VS Code. New users no longer need to install any extension to start using Copilot features such as chat, inline suggestions, and agents. Copilot is available out of the box as part of the standard VS Code installation.

This change is part of our ongoing effort to make VS Code the open source AI code editor. By shipping Copilot as a built-in extension, we reduce friction for new users and ensure that AI-powered features are seamlessly integrated from the first launch.

Existing users are not affected by this change. If you already have the Copilot extension installed, it continues to work as before.

As before, if you prefer not to use AI features, you can disable them with the chat.disableAIFeatures setting.

Enterprise

Group policy to filter agent network access

Administrators can now use group policies to control which network domains agent tools can access. When the chat.agent.networkFilter setting is enabled via policy, network access from agent tools such as the fetch tool and the integrated browser is restricted according to the allowed and denied domain lists.

• chat.agent.allowedNetworkDomains specifies which domains agent tools can access. Supports wildcards such as *.example.com.
• chat.agent.deniedNetworkDomains specifies which domains are blocked. Denied domains take precedence over allowed domains.

When the network filter is enabled and both lists are empty, all domains are blocked. When chat.agent.sandbox.enabled is also enabled, the network domain rules additionally apply to the terminal sandbox.

These policies are configured with keys ChatAgentNetworkFilter, ChatAgentAllowedNetworkDomains, and ChatAgentDeniedNetworkDomains. Learn more about enterprise policies in the 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:

• Add a chat tool for creating pull requests.
• Worktrees can also be deleted from the "Delete Local Branches and Remotes" command.

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

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 is managed at the organization level. Contact your administrator to change it. . 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

Contributions to our issue tracking:

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

Contributions to vscode:

• @AndreasArvidsson (Andreas Arvidsson): Fix TextmateSnippet clone method to correctly assign _children PR #295555
• @gryan11 (Gabriel Ryan): Fix: add missing override modifiers in test mock class PR #308558
• @maruthang (Maruthan G)
  • fix: preserve code block toolbar visibility during chat streaming PR #307978
  • fix: strip ANSI escape codes from inline test output messages PR #308161
  • fix: resolve default view for markdown files on first startup PR #308739
• @romalpani (Rohan Malpani): feat: enhance sessions view with find widget and header actions PR #307679
• @winstliu (Winston Liu): Fix --prof-startup never being able to profile renderer/extension host PR #307849
• @yogeshwaran-c (Yogeshwaran C)
  • Add scrollbar indicators for failing tests PR #307996
  • fix: check message location visibility for failureInVisibleDocument peek PR #308697
  • Show breakpoint widget on Alt+click in gutter PR #308687
  • fix: exclude source annotations from text selection in debug console PR #308925
• @zackbach (Zack Eisbach): Add support for regex in tokenTypes PR #304885

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

Welcome to the 1.115 release of Visual Studio Code. This release makes your agent-native development experience even better with the introduction of the new VS Code Agents companion app!

• VS Code Agents app: a new companion app optimized for agent-native development, running alongside VS Code Insiders.
• Integrated browser: several improvements to make working with the integrated browser more seamless for agents.
• Terminal tools: new capabilities for agents to interact with background terminals.
• BYOK for Business and Enterprise: bring your own language model key is now available for Copilot Business and Enterprise users.

Happy Coding!

Visual Studio Code Agents (Preview)

Visual Studio Code Agents is a new preview companion app that ships alongside VS Code Insiders, built for agent-native development.

• Parallelize tasks across projects - Kick off agent sessions across multiple repos in parallel (each isolated in its own worktree), quickly switch context (with UI that adapts to your selection), and iterate on human and agentic reviews.
• Monitor and review - Track session progress, view diffs inline, leave feedback for agents, and create pull requests without leaving the app.
• Your customizations carry over - Custom instructions, prompt files, custom agents, MCP servers, hooks, and plugins all work in the Agents app, along with your other VS Code customizations like themes, for example.
• No extra install - The app ships alongside VS Code Insiders. Launch it from your Start menu or Applications folder in the OS, or run Chat: Open Agents Application from the Command Palette.

The Agents app is a rapidly evolving preview. It's currently only available in VS Code Insiders, and we're looking forward to getting your feedback in GitHub issues.

Integrated browser

This release, we continue to further enhance the integrated browser experience and its capabilities for agents.

Browser agent tools improvements

Setting: workbench.browser.enableChatTools

Better tool labels

When an agent invokes the browser tool, the tool calls now have a more descriptive label and a link to go directly to the target browser tab.

Old:

New:

Long-running script support

The Run Playwright Code tool has improved support for long-running scripts. Scripts that take longer than five seconds to run (by default) now return a deferred result for the agent to poll.

Fewer duplicate tabs

Agents are now more heavily discouraged from repetitively opening browser tabs. Now, when an agent attempts to open a new tab and an available tab is already open to the same host, no new tab is opened unless an explicit flag is passed by the agent.

Pinch-to-zoom in the integrated browser (macOS)

The integrated browser now supports pinch-to-zoom on macOS. Use the trackpad pinch gesture to magnify web page content up to 3x.

Unlike the standard browser zoom (Ctrl+= / Ctrl+-), pinch-to-zoom is a purely visual magnification and doesn't reflow the page layout.

Terminal tools improvements

This release improves the agent experience for running terminal commands in the background.

Send input to background terminals

Previously, background terminals were read-only, with only get_terminal_output available. This was particularly limiting when a foreground terminal timed out and moved to the background, as the agent could no longer interact with it.

With the new send_to_terminal tool, the agent can continue interacting with background terminals. For example, if an SSH session times out while waiting for a password prompt, the agent can still send the required input to complete the connection.

Background terminal notifications (Experimental)

Setting: chat.tools.terminal.backgroundNotifications

Previously, when a terminal command was running in the background, the agent had to manually call get_terminal_output to check on its status. There was no way to know when the command completed or needed input.

With the new experimental chat.tools.terminal.backgroundNotifications setting, the agent is automatically notified when a background terminal command finishes or requires user input. This also applies to foreground terminals that time out and are moved to the background. The agent can then take appropriate action, such as reviewing the output or providing input via the send_to_terminal tool.

GitHub Copilot

Bring your own key for Copilot Business and Enterprise

Bring your own language model key (BYOK) is now available for Copilot Business and Enterprise users. With BYOK, you can use your own API keys to access models from providers like OpenRouter, Ollama, Google, OpenAI, and more in chat.

To enable BYOK for your organization, an administrator must enable the Bring Your Own Language Model Key in VS Code policy in the Copilot policy settings on GitHub.com. After the policy is enabled, organization members can add models from built-in providers or install language model provider extensions.

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

• vscode#304257 - terminal restart for integrated pwsh can cause cursor to go to wrong location
• vscode#304679 - Caps Lock key inserts raw escape sequence "[57358u" in Claude Code inside VS Code terminal

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

• @andysharman: feat: add A/B test for default new session mode PR #306532
• @chetanr-25: Improve type safety for dynamic stylesheet rules PR #288651
• @danplischke (Dan Plischke): Add default-folder, default-workspace and disable-telemetry to serve-web CLI PR #299512
• @mossgowild (moss): fix: prevent catastrophic regex backtracking in _extractImagesFromOutput PR #307447
• @xingsy97 (xingsy97): comments: fix memory leak when recycling tree items in comment panel PR #304666
• @yogeshwaran-c (Yogeshwaran C): fix: scope editor service in window title to own editor groups container PR #306226
• @yogeshwaran-c (Yogeshwaran C): fix: preserve 'Wait for Breakpoint' selection when reopening breakpoint widget PR #306564
• @yogeshwaran-c (Yogeshwaran C): fix: include additional toggles in find input arrow key navigation PR #306559
• @yogeshwaran-c (Yogeshwaran C): feat: show coverage indicators in minimap PR #307250
• @yogeshwaran-c (Yogeshwaran C): fix: improve test coverage filter quickpick readability PR #306562
• @yogeshwaran-c (Yogeshwaran C): fix: treat unrecognized @-prefixed text as regular filter in test explorer PR #307555

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

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

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