Visual Studio Code Updates & Release Notes

Welcome to the 1.134 release of Visual Studio Code.

This release helps you work across windows, organize related chats side by side, and navigate long conversations faster.

• Side-by-side chats: Arrange related chats and subagent chats in groups for easier comparison.
• Prompt timeline: Quickly navigate across prompts and review their file changes.
• Find in chat: Search for text in the complete conversation with ease.
• Preview HTML files: Preview local HTML files directly in VS Code by making the integrated browser their default editor.

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

Agent host

The agent host lets you connect to the same agent session from multiple VS Code windows. It runs agent harnesses in a dedicated process based on the Agent Host Protocol (AHP). The agent host's Copilot agent is powered by the Copilot SDK, which aligns the agent's behavior and functionality with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

We're actively developing the agent host. The following screenshot shows the Copilot harness selected for an agent host in an editor window:

You can learn more in our VS Code Agent Host documentation. If you have any feedback or requests, please let us know by filing an issue.

Grid layout for chats in a session

Keep related conversations visible by arranging chats in horizontal or vertical groups. Drag chats or subagent chats into a group to compare results or monitor work side by side. VS Code restores the chat-group layout and focus when you return to the session or reload the window.

Create a side chat to open a new conversation beside the current chat.

Drag and drop a subagent chat into a group to view it side by side with the current chat.

You can also Alt+select a chat in the Chats picker to open it to the side.

Improvements to the side pane layout

Settings: sessions.layout.singlePaneDetailPanel and workbench.editor.showTabs

The single-pane layout keeps session details and editors in a shared tab bar next to chat. This release makes the layout easier to control:

• The layout follows the workbench.editor.showTabs setting. Multiple tabs remain visible, while the single and none values use a compact single-title header.
• Text file editors use the same header structure as the Changes editor, with file breadcrumbs in the header.
• The side pane keeps its size and visibility when you switch sessions, avoiding unexpected layout shifts.

Enable sessions.layout.singlePaneDetailPanel and reload the window to use this layout.

Prompt timeline

Setting: sessions.chatTimeline.display

Long agent sessions can make it difficult to find earlier prompts and identify which ones changed files.

The Agents window includes a timeline in the transcript gutter. Each dot represents one of your prompts, and the highlighted dot marks your current position. Hover over the timeline to view your prompts, then select one to jump to it. For prompts that changed files, the list shows the number of lines added and removed and lets you open the changes directly for review.

Use the sessions.chatTimeline.display setting to show the timeline beside the scrollbar (ruler) or hide it (off).

Chat

Find in chat

Finding information from earlier in a long conversation previously required scrolling through the transcript. Use Ctrl+F to search conversations in the Chat view, chat editors, and the Agents window.

Search includes the entire conversation, even content that is not currently rendered on screen. As you move between matches, VS Code scrolls each match into view and expands a collapsed work summary if it contains the match. You can also match case, match whole words, or use regular expressions.

Editor Experience

Close other editors from a tab

Keep one editor open without using the tab context menu. Hold Alt to change the close action on each editor tab to Close Other Editors, then select the action on the tab you want to keep.

Open HTML files in the integrated browser by default

Setting: workbench.editorAssociations

If you often preview local HTML files instead of editing them, set the integrated browser as their default editor. Configure this behavior with the workbench.editorAssociations setting or from the editor header.

The integrated browser provides the same features as a standalone browser tab while remaining associated with the HTML file. To preserve this association, links and other navigation open in new tabs.

Thank you

Contributions to vscode:

• @a1exmozz: agentHost: Emit user message telemetry to CTS PR #329961
• @abmahdy (Ahmed Mahdy): Preserve instructions for terminal completion notifications PR #330570
• @benelog (Sanghyuk Jung): Fix duplicated word in Copilot prompt text PR #328961
• @cipheraxat (Akshat Anand): Modern UI tabs: reserve close-button column so it doesn't overlay filename (fix #329605) PR #330754
• @jadefr (Jade Ferreira Vieira): Feature/alt click close other tabs PR #328975
• @martincheck (Martin Check): chat: avoid splitting surrogate pairs in read_file PR #331005
• @marvinroger (Marvin ROGER): Fix crash due to undefined document.queryCommandSupported PR #330298
• @mirimadahmed (Mir): voice: honor the new_session flag on send_to_chat PR #330859
• @Shaurav-Vora (Shaurav Vora): Co-authored: Implement Ctrl+F find widget support for chat panes and editors PR #330340
• @SimonSiefke (Simon Siefke):
  • fix: memory leak in extensions view PR #330210
  • fix: memory leak in source control view PR #330241
  • fix: memory leak in code actions PR #330142
  • fix: memory leak in search view PR #330240
  • fix: memory leaks in chat widgets PR #326876
  • fix: memory leak in references view PR #330191
  • fix: memory leak in search result folder matches PR #331012
• @yzxcj797: docs: fix dead nes-video.gif link in copilot extension README PR #330992

Issue tracking

Contributions to our issue tracking:

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

We appreciate people trying our new features as soon as they are ready. Check back often to 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.133 release of Visual Studio Code

This release gives you more flexibility in Claude sessions, keeps long chats easier to follow, and refreshes local HTML previews as you work.

• Change model provider for Claude sessions: Switch providers between turns without reconfiguring the agent host.
• Agents window without GitHub sign-in: Use Claude with your existing API key when GitHub sign-in is unavailable.
• Auto-reload HTML files: Preview HTML changes immediately without manual refresh.

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

Agent host

The agent host lets you connect to the same agent session from multiple VS Code windows. It runs agent harnesses in a dedicated process based on the Agent Host Protocol (AHP). The agent host's Copilot agent is powered by the Copilot SDK, which aligns its behavior and functionality with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

We're actively developing the agent host. The screenshot below shows how to select the Copilot harness on the agent host in the editor window:

You can learn more in our VS Code Agent Host documentation. If you have any feedback or requests, please let us know by filing an issue.

Mix Anthropic and Copilot models in Claude sessions

Previously, a Claude session ran entirely through either your GitHub Copilot subscription or Claude's existing configuration, such as an API key. Switching providers required reconfiguring the agent host.

Now, the model picker displays both groups, so you can switch providers between turns. The model you select is used for the next turn. Models under Anthropic bill your API key, and models under Copilot use your Copilot subscription.

Open the Agents window without GitHub sign-in (Experimental)

Setting: chat.agentHost.allowSignedOutWhenUsable

The Agents window used to open with a GitHub sign-in prompt you could not dismiss. That blocked anyone whose machine can't reach github.com or anyone who doesn't interact with GitHub. Users with Claude already configured with an API key who don't need GitHub sign-in had this extra step.

Enable this setting to open the Agents window without signing in to GitHub. GitHub authentication is then associated with individual agents or models instead of the Agents window. In this release, this behavior only supports Claude. Support for Copilot with your own model keys and Codex is planned for future releases.

Chat

Sticky scroll for prompts

Setting: chat.stickyScroll.enabled

When you scroll through a long conversation, you can lose track of which prompt a response belongs to. The prompt you have scrolled past now stays pinned to the top of the chat, similar to sticky scroll in the editor.

The pinned prompt shows its position in the conversation. Select it to jump back to that prompt, or use the previous and next buttons beside it to step through your prompts.

Editor Experience

Auto-reload HTML files in the integrated browser

Setting: workbench.browser.autoReloadOnFileChange

When a local HTML file is open in the integrated browser, it now refreshes automatically when the file changes on disk.

This helps you see agent edits or your own saved changes immediately. You can toggle automatic reload for individual browser tabs and configure the default with the workbench.browser.autoReloadOnFileChange setting.

Deprecated features and settings

None

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops): voice: explain why a voice connection failed, Rename Voice Mode voices to approved names
• @benelog (Sanghyuk Jung): Fix duplicated word in notebook.cellToolbarLocation setting description
• @Bosphoramus (Tony): fix: add top gap for Modern UI floating panels when title bar is hidden
• @bstee615 (Benjamin Steenhoek): Add optional rejected edit memory to diffpatch prompt
• @karthikkatu (Karthikeyan M): Auto-reload Integrated Browser when previewed local file changes
• @lfraleigh (Lori Fraleigh): Add missing Azure SDK for Go modules to GoModulesToLookFor
• @mateusabelli (Mateus Abelli): Update Copilot extension links
• @rfeltis (Ralph Feltis): Add Agents window startup A/A experiment trigger
• @ShehabSherif0 (Shehab Sherif): Fix operator precedence in timeline pageSize calculation
• @SimonSiefke (Simon Siefke): fix: memory leak in PerfModelContentProvider
• @SVOG23 (Suraj Vaghela): docs: fix stale relative paths in Claude chat sessions AGENTS.md
• @vscodebot-pr (VS Code PR Bot): fix: guard against stale line numbers in test decorations (fixes #328988)
• @Xaena53 (Bedirhan ÇETİN): refactor: share the find input toggle navigation

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

Welcome to the 1.132 release of Visual Studio Code

This release brings element-level feedback in the integrated browser, multilingual dictation, side chats, and Markdown diffs in the hybrid Markdown editor.

• Commenting in the integrated browser: Give agents precise feedback by commenting on specific web page elements.
• Multilingual dictation: Dictate in multiple languages with an on-device model that follows your language preference or detects the language automatically.
• Side chats with /btw: Ask contextual questions without interrupting the current agent turn.
• Markdown diffs in the hybrid Markdown editor (Experimental): Review changes in rendered Markdown while continuing to edit the modified document.

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

Agent host

The agent host lets you connect to the same agent session from multiple VS Code windows. It runs agent harnesses such as Copilot, Claude, and Codex in a dedicated process based on the Agent Host Protocol (AHP). The agent host's Copilot agent is powered by the Copilot SDK, which aligns its behavior and functionality with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

We're actively developing the agent host and progressively rolling it out to users. The screenshot below shows how to select the Copilot harness on the agent host in the editor window:

You can learn more in our VS Code Agent Host documentation. If you have any feedback or requests, please let us know by filing an issue.

Agents window

The Agents window gives you a dedicated space to start and monitor multiple agent sessions.

Track session activity from the chat input

When an agent works across files, subagents, previews, and browsers, you can use live status pills above the chat input to follow its progress and quickly return to related work. The pills update with the activity for the session you are viewing:

• Changes summarizes the number of changes. Select it to view the changes for the current turn in a multi-file diff that updates live.
• Previews provides access to Markdown previews for files the agent creates or edits.
• Subagents lets you follow what the agent is doing in a subagent by opening its work in a separate chat.
• Browsers lets you follow along while the agent interacts with an integrated browser.

Switch editor types

Setting: breadcrumbs.showEditorType

When multiple editor types are available, an editor type dropdown in the Agents window shows the current editor and lets you switch between the available regular and diff editors instead of using the Reopen Editor With command. You can also change the default editor from the dropdown. The dropdown uses the right side of the breadcrumb bar, which also provides file navigation in the Agents window.

To show the editor type dropdown in editor windows, enable breadcrumbs.showEditorType.

Side chats with /btw

When you want to ask a question without interrupting the current turn, you can open a side chat by typing /btw in the chat input. The side chat shares the context and prompt cache of your primary chat, so you can ask questions about the current turn. Similarly, you can select text in a chat response to ask contextual questions about that response.

You can also share context by referencing chats in other chats, either by dragging the chat tabs into the input box, or typing #chat: and then picking the title of the chat to include.

Chat

Terminal output reflow

Expanded terminal output in Chat reflows to the available width as the view is resized. Previously, output used a fixed width, which caused lines to wrap too early and left unused space in wider views.

This improvement applies to terminal output from both the Local agent harness and the Copilot harness running on the agent host.

Editor experience

Dictation onboarding and customization

Setting: agents.voice.language

The built-in dictation converts speech to text in chat inputs, editors, and terminals. When you use dictation for the first time, an onboarding experience helps you verify the selected microphone before you start. It shows a live microphone waveform, provides a device picker when multiple microphones are available, and links to dictation settings and customization. You can reopen this experience with Voice Mode: Show Introduction from the Command Palette.

Dictation now uses multilingual Nemotron 3.5 as its default on-device model. The model keeps audio on your device and follows agents.voice.language. With automatic language selection, dictation uses your system or browser locale when supported and otherwise lets the model detect the language.

To adapt the final transcript to project terminology or formatting preferences, run Voice: Configure Dictation Instructions. VS Code combines instructions from ~/.copilot/dictation.md and .github/dictation.md in trusted workspaces. These instructions supplement the built-in cleanup rules, which preserve the meaning of your speech and prefer numerals where appropriate.

If network restrictions prevent the on-device model from downloading, the error notification provides an action to import an official Foundry Local model package from disk. During a normal first-use download, the microphone button shows progress instead of placing download text in the input.

Markdown diffs in the hybrid Markdown editor (Experimental)

In the previous release, we introduced the hybrid Markdown editor, which combines rendered Markdown with in-place editing and agent-actionable comments. In this release, Markdown diffs can open in the hybrid Markdown editor. The modified document remains editable, while gutter indicators highlight added, changed, and deleted content. You can use the editor type dropdown to switch between text diff and the Markdown editor with diff annotations.

Commenting in the integrated browser

To provide feedback on web pages, it is often useful to comment on specific elements. In this release, the integrated browser adds support for selecting web page elements and annotating them with agent feedback. You can trigger this mode by using the workbench.action.browser.addElementCommentToChat keyboard shortcut.

In this mode, you can select multiple elements and add a comment to each before sending to the chat.

Terminal

Better dictation for terminal commands

Terminal dictation applies shell-aware cleanup, so spoken commands preserve shell syntax. For example, saying "git commit dash m hello world" produces git commit -m "Hello World" instead of inserting the words literally.

Select the active microphone button to stop recording.

Proposed APIs

Configure custom editor priorities by editor mode

The proposed customEditors.priority feature lets extensions choose different priorities for text and diff editors. For example, an extension can use its custom editor by default for regular files while keeping the built-in editor as the default for diffs and vice versa.

Existing single priority values continue to work, and diff editors use explicit by default. Extension authors can learn more about configuring custom editor priorities. We plan to promote this feature to stable in the next release.

Deprecated features and settings

New deprecations in this release

• Agent host policy

The ChatAgentHostEnabled policy is removed, so administrators can no longer centrally disable the agent host through policy. Developers can continue to use chat.agentHost.enabled to choose whether agents run in the separate agent host process.

Upcoming deprecations

There are no upcoming deprecations.

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops)
  • Voice: answer question carousels by voice PR #327899
  • Voice: queue concurrent question forms instead of swapping them PR #328205
• @alexander-zw (Alexander Wu): [trivial] Add example sources to docstrings in cursorEvents.ts PR #241250
• @AndyBodnar (Andy ): customEditor: fix stale cache after file deletion PR #287966
• @AntonioLujanoLuna (Antonio Lujano Luna): Preserve inbound Anthropic PDF documents PR #325833
• @Bestra (Chris Westra): Log organization resource cache creation failures PR #326958
• @bstee615 (Benjamin Steenhoek): Set default NES aggressiveness to medium PR #327049
• @denizguney (Deniz Güney Yıldırım): feat: add getAccessibilityStatus PR #328018
• @dsavy4 (Dmitry Savy)
  • Fix stableStringify treating shared references as circular PR #327398
  • Fix BidirectionalMap leaving a stale reverse entry on key update PR #327403
• @EmrecanKaracayir (Emrecan Karaçayır): Fix for missing terminal suggest symbol icon css mappings PR #293158
• @jdanbrown (Dan Brown): Terminal tab title: Show "~" instead of "$HOME" PR #275378
• @KevinWang-wpq: Remove stale secrets after decryption failure PR #324014
• @mirimadahmed (Mir)
  • Voice: warm capture before hands-free playback PR #328225
  • Make coding agent voice aware for better voice experience PR #328217
• @Moli13337 (Moli): docs: Fix incorrect directory paths in CONTRIBUTING.md files PR #325810
• @Mr-Nilarnab (MR NILARNAB GITHUB): docs: fix minor typos and grammar in README PR #325006
• @Muszic (Sangeet): fix: correct ArrayQueue boundaries in takeWhile and takeFromEndWhile PR #301119
• @ohah (ohah): fix: file-found Badge vertical PR #273098
• @peterdanwan (Peter Wan): fix: signature help's active overload not updating PR #320980
• @praneethhere (Praneeth Kodumagulla): Support COPILOT_HOME for Copilot CLI state PR #314917
• @RedCMD (RedCMD): fix: bug in Restrict continue comment PR #322668
• @rushil-b-patel (Rushil Patel (rusp)): feat: add copy button to code blocks in markdown preview PR #323609
• @samir-nimbly: Fix chat image attachments silently dropped when signed out of GitHub PR #323856
• @SimonSiefke (Simon Siefke)
  • fix: memory leak in titleBarPart PR #327552
  • fix: memory leak in notebook view model PR #328208
  • fix: memory leak in decorationAddon._decorations PR #326933
  • fix: memory leak in chatServiceImpl PR #327128
  • fix: memory leak in settings-tree PR #327909
  • fix: memory leak in historyService PR #327518
• @sricursion (Sriraj): Escape dynamic values in the customizations index PR #327475
• @thernstig (Tobias Hernstig): Fix forwarded ports status bar item to toggle the ports view PR #320090
• @Vector341: [html] fix validation error on JavaScript block comment (for #171153) PR #240932
• @yogeshwaran-c (Yogeshwaran C)
  • fix(javascript): sync JSDoc continuation patterns with TypeScript language config PR #308433
  • [json] add #region folding markers to language configuration PR #318515
  • Add package.json catalog support for npm completions and hover PR #307989
  • Show keybinding in Toggle Search Details tooltip PR #311859
  • fix(server): propagate --enable-proposed-api in serve-web PR #310207
  • fix: remove all manual folding ranges when selection is empty PR #304793
  • fix: detect interrupted commands in terminal exit code hack PR #307256
  • fix: wrap module script content in block scope to prevent false redeclaration errors PR #308027
• @zmr-233: Avoid :has() selectors that trigger workbench-wide style invalidation PR #327052

Issue tracking

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @MominRaza (Momin Ahmad)
• @palinkasnorbert (Norbert Palinkas)
• @IllusionMH (Andrii Dieiev)
• @ganlvtech (Ganlv)

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.131 release of Visual Studio Code. This release brings more visibility into running subagents, built-in dictation across the workbench, and a new hybrid Markdown editor.

• Subagents: See a running subagent's model, elapsed time, and active tool call without opening its conversation.
• Built-in dictation (Experimental): Dictate in chat, editors, and the terminal without installing the Speech extension.
• Hybrid Markdown editor (Experimental): View, edit, and add agent-actionable comments to Markdown files in the Agents window.

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

Agent host

As mentioned in our last few releases, we're rearchitecting how agent sessions work in VS Code around the agent host - a dedicated process that runs agent harnesses such as Copilot, Claude, and Codex, based on the Agent Host Protocol (AHP). Because a session lives in its own process, the same session can be connected to and rendered from multiple VS Code windows at once. The agent host's Copilot agent is powered by the Copilot SDK, which means that its behavior and functionality is aligned with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

We're actively developing the agent host and progressively rolling it out to users. To opt in, enable chat.agentHost.enabled and then select an agent host harness from the harness dropdown. The screenshot below shows how to select the Copilot harness on the agent host in the editor window:

You can learn more in our VS Code Agent Host architecture documentation. If you have any feedback or requests, please let us know by filing an issue.

More information about running subagents (Agents window)

When working on complex tasks, the agent can delegate tasks to subagents to run them in parallel in its own context window. You can now quickly see what a running subagent is doing without opening its conversation. In the Agents window, the main conversation shows the following information for each running subagent:

• The model used by the subagent
• How long the subagent has been running
• The tool that the subagent is actively calling

Select a running subagent to open its conversation in another chat, where you can review its full progress while the parent conversation remains available.

Chat

VS Code pet (Experimental)

A new highly experimental pet has been discovered in VS Code! Enter /vscode-pet in chat to meet your new companion.

Editor Experience

Built-in dictation across VS Code (Experimental)

Setting: dictation.enabled

This setting can be managed by your organization. Contact your administrator to change it.

Use dictation in VS Code, you no longer need to install the VS Code Speech extension. The built-in transcription service works in chat inputs, text editors, and the integrated terminal, with live text and controls suited to each surface. A single speech session and microphone selection are shared across all three surfaces, which prevents overlapping recordings and keeps dictated text in the intended location.

Built-in dictation uses the private, offline Nemotron model. The model downloads on first use and keeps audio on your device.

Use dictation.showTranscript to control whether the live transcript appears while you dictate. With dictation.experimental.llmCleanup enabled, Copilot refines your transcript as you speak by adding formatting and removing filler words. Transcript text is sent to a language model for cleanup. If cleanup is unavailable, VS Code keeps the raw transcript.

Platform support

The following platforms are supported for built-in dictation:

• Windows x64 and Arm64
• macOS on Apple silicon
• Linux x64 and Arm64 with glibc 2.34 or later
• Remote workspaces (because transcription runs on the local VS Code client)

The following platforms are not currently supported for built-in dictation:

• VS Code for the Web
• Intel-based Macs, 32-bit systems, and Arm32 systems

Support for more platforms and languages is a work in progress.

Hybrid Markdown editor (Experimental)

Setting: workbench.editor.markdownDefaultEditorInAgentsWindow

In this release, we introduce a new hybrid Markdown editor in the agents window. It lets you view Markdown files, edit them in-place, and add comments that an agent can act on.

By using Reopen Editor With you can switch between the text editor and this new Markdown editor, both in the Agents window and editor windows.

Accessibility

More control over terminal screen reader updates

Setting: terminal.integrated.accessibleViewPreserveCursorPosition

Screen reader users can read terminal output at their own pace while commands continue to produce output. Set terminal.integrated.accessibleViewPreserveCursorPosition to always to preserve the cursor position in the terminal Accessible View, including when new content arrives. Existing true and false values continue to work.

Terminal live updates also use a non-interrupting ARIA status announcement instead of an assertive alert. Output remains available to screen readers without repeatedly interrupting other speech.

Terminal

Control the terminal resize dimensions overlay

Setting: terminal.integrated.resizeDimensionsOverlay.enabled

If you find the columns-by-rows overlay distracting when resizing the terminal, you can disable it with the terminal.integrated.resizeDimensionsOverlay.enabled setting. The overlay remains enabled by default, and setting changes apply immediately to open terminals without a restart.

Languages

Python

Python Environments is the default environment-management experience in VS Code Stable and Insiders after its rollout reached 100% of users. Review the Python Environments rollout details and tracking.

Python projects start faster and spend less time refreshing environments. Conda discovery is deferred until needed, concurrent environment scans are consolidated, and Pylance can use the last-known interpreter while a full refresh continues.

Deprecated features and settings

None

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops): voice: make passive ptt_start the canonical hands-free narration fix PR #326405
• @bwateratmsft (Brandon Waterloo [MSFT]): Add a when clause context key for detecting if an extension is installed+enabled PR #326814
• @Kaidesuyoo (Kaidesuyo): fix performance regression caused by modern UI styles PR #325985
• @mirimadahmed (Mir): Fix voice barge in regression PR #326611
• @piyushmadan (Piyush Madan): Resolve execution subagent model by exact CAPI id before family fallback PR #324859
• @SimonSiefke (Simon Siefke):
  • fix: memory leak in abstractTaskService PR #326934
  • fix: memory leak in abstractRuntimeExtensionsEditor PR #326890
  • fix: memory leak in terminalProcessManager PR #326930
  • fix: memory leak in debugModel PR #327047
  • fix: memory leak in terminalService PR #327156
  • fix: memory leak in mainThreadTerminalService PR #327155
• @SixFive7 (Jori Huisman): Honor Explorer's minItems for the Windows taskbar jump list PR #318117
• @soreavis: Git - resolve the active notebook for Open Changes / Open File PR #326468

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

Welcome to the 1.130 release of Visual Studio Code.

This release brings agent host improvements, faster review workflows in the Agents window, better chat visibility, and smarter terminal link handling.

• The agent host: Run sessions in a dedicated process that you can connect to from multiple VS Code windows.
• Agents window improvements (Preview): Review multi-file changes faster with compact diffs, file-level stats, and worktree support across harnesses.
• Assisted tool approvals: Reduce approval interruptions by letting the model evaluate tool-call risk during agent tasks.
• Clickable file links in Git diffs with mnemonic prefixes: Open files directly from diff output when mnemonic prefixes are enabled.

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

The agent host

As mentioned in our last release, we're rearchitecting how agent sessions work in VS Code around the agent host - a dedicated process that runs agent harnesses such as Copilot, Claude, and Codex, based on the Agent Host Protocol (AHP). Because a session lives in its own process, the same session can be connected to and rendered from multiple VS Code windows at once. The agent host's Copilot agent is powered by the Copilot SDK, which means that its behavior and functionality is aligned with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

Learn more about the VS Code Agent Host architecture.

We're actively developing the agent host and progressively rolling it out to users in both the editor window and the Agents window. To opt in, enable chat.agentHost.enabled (This setting is managed at the organization level. Contact your administrator to change it.) and then pick an agent host harness from the harness dropdown. The screenshot below shows how to select the Copilot harness on the agent host in the editor window:

As we continue to invest in the agent host, some features might only be available when an agent runs on it. Those features link back to this section and, where relevant, note any additional settings that enable them (for example, chat.agents.claude.preferAgentHost to enable the Claude agent on the agent host).

If you have any feedback or requests while using the agent host, please let us know by filing an issue.

Assisted tool approvals

Setting: chat.assistedPermissions.enabled

Repeated tool approval prompts can interrupt long-running agent tasks. With assisted permissions, the language model evaluates the risk of each tool call and decides whether the tool can run or should require your approval.

Enable the setting to add Assisted permissions to the permissions picker for agents that run on the agent host. The following video compares default approvals with assisted permissions:

Agents window improvements (Preview)

The Agents window includes several updates that make it easier to review changes and manage chats. Updates that require a session running on the agent host are called out below.

File-level diff statistics

Each file header in the Changes editor shows live insertion and deletion counts next to the file path. You can quickly assess the size of each file's changes while scanning a multi-file diff.

Compact multi-file diff view

The multi-file diff uses a more compact gutter that removes empty space before the code. File headers, line numbers, and unchanged-region controls share a consistent alignment, which leaves more room for reviewing changes in a narrow editor.

Compact quick chats

Quick chats, which run on the agent host, use compact, single-line rows in the sessions list. Regular sessions retain a second line with change statistics, status, and timestamps, making quick chats easier to distinguish and leaving more room for project sessions.

Worktree support for all agent harnesses

Agent harnesses running on the agent host support worktree isolation. The New Worktree checkbox in the Agents window was previously only supported by the Copilot harness. Claude and Codex sessions also run in a Git worktree, making it easier to spin up parallel sessions for different features in the same workspace regardless of harness.

Chat

Chat timestamps

Setting: chat.verbose

Timestamps are shown for chat requests and responses. Hover over the message toolbar to view the timestamp and elapsed time for a chat interaction. You can disable this with chat.verbose.

Aggregate AI credit usage for Copilot Business and Enterprise

Copilot Business and Copilot Enterprise users can now see their aggregate AI credit usage for the current billing cycle directly in the Copilot status menu. Previously, credit usage was only surfaced when a user-level budget was configured, leaving many organization-managed users without visibility into how many credits they had consumed.

Now, when no user-level budget is set, the status menu displays the total number of credits used so far in the billing cycle. This gives you an at-a-glance view of your consumption, so you can better understand your usage patterns without leaving the editor.

Terminal

Clickable file links in Git diffs with mnemonic prefixes

You can open file links directly from Git diff output in the terminal when Git's diff.mnemonicPrefix option is enabled. VS Code recognizes prefixes such as i/ for the index and w/ for the working tree, and removes the prefix from the link target so the correct file opens.

When mnemonic prefixes are enabled, VS Code also recognizes the numeric 1/ and 2/ prefixes produced by git diff --no-index.

Engineering

The VS Code repository is compiled using the release version of TypeScript 7. We also switched to the release version of the TypeScript 7 extension. Read the TypeScript 7.0 release announcement from the TypeScript team.

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops): Voice: opt out of backend auto-narration (auto_narrate: false), voice: send request_narration only after session context is sent, voice: NACK + client revalidation for dropped narration
• @ahmadawais (Ahmad Awais): Detect Command Code as an agent CLI for terminal tab titles
• @AntonioLujanoLuna (Antonio Lujano Luna): Fix BYOK Anthropic endpoints sending PDFs as image blocks
• @arham766 (Shahrier Islam Arham): chore: bump windows-process-tree to 0.8.0 to fix UTF-8 command lines in Process Explorer
• @clintharrison (Clint Harrison): Support mnemonic prefixes in git diff parsing for terminal links
• @justjavac (迷渡): Decorations: fall back to lower-priority colors
• @kobihikri (Kobi Hikri): Remove dead CODEOWNERS rules for deleted no-package-lock / no-yarn-lock workflows
• @mirimadahmed (Mir): Handle voice barge-in playback, Fix voice barge-in protocol, Voice agent send voice language locale from the client, Voice agent always on streaming mode to support barge in, Add scoped live Voice transcripts
• @pony-maggie (Lucas Ma): Avoid stale simple dialog folder updates, Allow simple file dialog to create nested folders
• @rfeltis (Ralph Feltis): Fix quota trajectory billing period calculation
• @smorimoto (Sora Morimoto): Recognise OCaml in settings labels
• @spokodev: fix: match uppercase query characters in fuzzyContains
• @UditDewan (udit): Fix tunnelProtocol context key always resolving to https on focus

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: July 15, 2026

Update 1.129.1: The update addresses these issues.

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

Welcome to the 1.129 release of Visual Studio Code. This release brings a dedicated agent host, a new editor panel in the Agents window, running commands with !, and a preview of the modern UI.

• The agent host: Run agent sessions in a dedicated process and connect to them from multiple windows.
• New editor panel in the Agents window (Experimental): Review agent-generated files and diffs in a docked editor.
• Run commands with ! prefix: Run terminal commands directly from chat prompts.
• Modern UI preview (Experimental): Get a first look at the updated VS Code workbench appearance.

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

The agent host

We're rearchitecting how agent sessions work in VS Code around the agent host - a dedicated process that runs agent harnesses such as Copilot, Claude, and Codex, based on the Agent Host Protocol (AHP). Because a session lives in its own process, the same session can be connected to and rendered from multiple VS Code windows at once. The agent host's Copilot agent is powered by the Copilot SDK, which means that its behavior and functionality is aligned with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

Learn more about the VS Code Agent Host architecture.

We're actively developing the agent host and starting to roll it out to users in both the editor window and the Agents window. To opt in, enable chat.agentHost.enabled (This setting is managed at the organization level. Contact your administrator to change it.) and then pick an agent host harness from the harness dropdown. The screenshot below shows how to select the Copilot harness on the agent host in the editor window.

As we continue to invest in the agent host, some new features in these release notes may only be available when an agent runs on it. Those features link back to this section and, where relevant, note any additional settings that enable them (for example, chat.agents.claude.preferAgentHost to enable the Claude agent on the agent host).

New editor panel in the Agents window (Experimental)

The Agents window shows your conversation with an agent next to a detail area for the files and changes it produces. This release introduces a redesigned editor panel that brings the editor and the detail area together into one docked pane with a shared tab bar, so reviewing an agent's work feels like working in the main editor instead of switching between separate panels.

With the new editor panel, you can:

• Open files and diffs directly inside the docked editor, next to your chat, and add tabs with a New Tab action that matches the chat tab strip.
• Review changes in the Changes view with an improved diff experience: toggle between inline and side-by-side views, expand or collapse all files at once, and read changes in a more compact diff representation that fits more of the change on screen. The next action, such as Create Pull Request, is available right from the editor tab title, and editor keybindings like toggling the diff view work the same as they do in the main VS Code window.
• Pick up where you left off. Each session restores its side-pane width, open editors, active editor, and per-file collapsed state across session switches and window reloads.

This is an experimental, opt-in layout. To try it, enable sessions.layout.singlePaneDetailPanel and reload the window, since the setting is read once at startup.

Session-management tools for Agent Host sessions

Agents running on the agent host (Copilot, Claude, and Codex) now have access to a suite of session-management tools, so an agent can enumerate, create, observe, and act on other sessions and chats without you needing to switch away from your current conversation.

With these tools, an agent can:

• List your sessions with their status, workspace, and changes, so it can find the right one to act on. Archived sessions are excluded unless explicitly requested.
• Read another session's recent conversation to understand what it's doing.
• Create a new session or a new chat within an existing session to hand off a sub-task, rather than overloading a single conversation with unrelated work.
• Send a message to a session or chat it created, to kick off or steer that work.

Whenever a tool creates or targets a session, VS Code renders an Open Session pill so you can jump straight to it. Sending a message to another session always asks for your confirmation first. An agent can't message its own chat, and a burst of sends is capped so a single request can't fan out into an unbounded number of sessions.

Agents window improvements

This release includes several smaller improvements to the Agents window new-session flow:

• Remembered new-session defaults: the new-session picker remembers your last agent mode and approvals choices and uses them as the defaults the next time you create a session, so you don't have to reselect the same options for every task.
• Worktree checkbox: instead of choosing between folder and worktree isolation from a dropdown, the new-session configuration shows a single New Worktree checkbox. Check it to run the session with Git worktree isolation, which keeps the agent's changes in a separate folder until you're ready to review and merge them, or leave it unchecked to use folder isolation.

Chat

Run commands with ! prefix

You can now prefix chat messages with a ! to run their contents as terminal commands. This works in agent host sessions both in the editor and Agents window.

BYOK models with the Copilot agent harness

You can now use Bring Your Own Key (BYOK) models in the Agents window when you select the Copilot harness running on the agent host.

Migrate prompt files to skills (Experimental)

Prompt files (*.prompt.md) are used to describe custom slash commands. They are only supported in the Local agent harness while other harnesses express slash commands with skills. For compatibility across harnesses, we recommend to migrate all prompt files to skills.

With chat.customizations.promptMigration.enabled enabled, if you select a harness running on the agent host and you have migratable prompt files, you'll now see a 'Migrate Prompts' entry in the AI Customizations overview.

The migration interface lets you:

• View prompt files from both workspace (.github/prompts/) and user data locations.
• Migrate selected files to skills and open the newly created skills.

Editor experience

Reopen an editor from the editor toolbar

When a file or diff supports multiple editors, you can switch editors directly from the editor toolbar. Open the ... menu and select an editor from the Reopen Editor With submenu. This makes alternative editors easier to discover without using the Command Palette.

Modern UI preview (Experimental)

Setting: workbench.experimental.modernUI

You can now preview a modernized VS Code UI that updates the look and feel of the editor workbench. This is currently an experimental feature that you can enable with the workbench.experimental.modernUI setting and is enabled by default in Insiders builds.

Authentication

GitHub Enterprise support for Copilot in the agent host

Developers whose GitHub Copilot access is provided through a GitHub Enterprise (GHE) instance can sign in and use Copilot in VS Code. Previously, the agent host's Copilot authentication only supported github.com, so a GHE-backed Copilot subscription could not complete sign-in: both the OAuth flow and the Copilot token request targeted github.com.

With this release, VS Code can authenticate Copilot against a GitHub Enterprise instance. When you sign in to Copilot, choose your GitHub Enterprise instance, and VS Code runs the sign-in flow and requests Copilot access tokens from that host instead of github.com. This works in both the editor window and the Agents window, and with both the Copilot and Claude agents.

Because this support is part of the agent host, ensure the agent host is enabled with chat.agentHost.enabled (This setting is managed at the organization level. Contact your administrator to change it.).

Proposed APIs

Configure custom editors for diff and merge editors

Custom editors now opt out of diff and merge editors by default. As a result, a file can continue to open in a custom editor while its diffs and merges open in the built-in text editors. You might notice this change if you previously saw a custom editor when opening a diff or merge editor.

To open a diff in another editor, use the Reopen Editor With submenu in the editor toolbar. To always use a specific editor for matching diffs, configure the workbench.diffEditorAssociations setting.

The proposed customEditorPriority API provides separate priorities for files, diffs, and merge editors:

{
  "priority": {
    "textEditor": "default",
    "diffEditor": "option",
    "mergeEditor": "never"
  }
}

The new never priority prevents automatic selection for that editor type while keeping the editor available for explicit selection.

If the text diff editor cannot display binary content, VS Code still falls back to a compatible custom diff editor.

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops): chat/voice: land voice answers on question carousels (fix Skipped) PR #323161
• @cipheraxat (Akshat Anand): Fix Modern UI editor tab decoration color on full label PR #325291
• @danielrobbins (Daniel Robbins): Fix bugs related to setting the right Chat model. (Fixes Issue #323765) PR #323767
• @dobbydobap (varshitha):
  • Fix second Rerun Last Task failing to launch for reevaluateOnRerun tasks PR #324571
  • Unstick a pinned tab dragged to the start of the unpinned row PR #324734
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #321221
• @Kaidesuyoo (Kaidesuyo): fix persistent workbench UI performance degradation PR #324986
• @myselfsiddharth (Siddharth Mehta): debug: right-align toolbar actions in exception widget PR #325077
• @theanarkh (theanarkh):
  • workbench: fix ObjectSettingCheckboxWidget memory leaky PR #323670
  • fix: make sure register handler when ipc emitter add listener PR #323663
• @yavanosta (Dmitry Guketlev): Use startColumn in growUntilVariableBoundaries PR #324523

Issue tracking

Contributions to our issue tracking:

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

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.128 release of Visual Studio Code. This release brings richer multi-chat agent sessions, generally available image support in Chat, and OS-level keyboard shortcuts.

• Multi-chat agent sessions: Run several related chats in one Claude session to compare approaches and work in parallel.
• Quick chats: Ask a question in the Agents window without opening a workspace first.
• Copilot Vision: Attach images and PDFs to Chat by pasting, dragging, or dropping them, now generally available.
• Browser tab placement: Choose where integrated browser tabs open: the active group, a dedicated side group, or a separate window.
• OS-level keyboard shortcuts: Trigger VS Code commands with keybindings that work even when VS Code isn't focused.

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

Multiple chats in a session now supports Claude agent

Claude agent-host sessions in the Agents window provide agentic coding capabilities powered by Anthropic's Claude Agent SDK directly in VS Code. Multiple chats keep related conversation threads in one session instead of spreading them across separate top-level sessions.

Single-chat Claude sessions remain a focused way to work with the agent. With multiple chats, a session can contain related chats, so you can compare approaches, branch from an earlier turn, and run work in parallel. You can add chats, fork a chat from an existing turn, switch between peer chats, and send turns concurrently. Each chat keeps its own history, title, and model selection, and restores with the parent session after restart. Peer chats stay grouped under the Claude session and don't appear as separate top-level sessions.

The following video shows a single Claude session with multiple chats: the main chat adds a /health endpoint to an Express app, while a peer chat writes tests for it in parallel, and a forked chat explores an alternative implementation. Each chat runs independently and stays grouped under the same session.

Chat without a selected workspace in the Agents window

The Agents window gives you a dedicated place to create, resume, and manage agent sessions. For project work, those sessions keep the chat, files, and changes together with the workspace.

For questions not tied to a folder, you can now start a chat in the Agents window without selecting a workspace. These chats appear in the Chats section and open focused and ready for input. Start a quick chat with unassigned or the plus button on the Chats section header.

Because a quick chat is workspace-less, it does not show the workspace-specific Changes or Files side pane. Quick chats are restored with your other sessions after reload and remain separate from workspace sessions.

Chats without a workspace are supported only by agent host sessions, so this experience is available when the agent host is enabled with chat.agentHost.enabled. This setting is managed at the organization level. Contact your administrator to change it.

The Pinned and Chats groups stay visible when empty by default. Use sessions.list.showEmptyDefaultGroups to hide these default groups until they contain sessions.

Read-only subagent chats in the Agents window (Preview)

When an agent delegates work to subagents, you can follow each worker's progress without interrupting or steering it from the main conversation. The Agents window provides a dedicated space for agent-driven workflows across projects, with chat and sessions as the primary interface.

When a session spawns subagents, their transcripts appear as read-only peer chats. Subagent chats are hidden from the tab strip until you open them from the Conversations menu, the running-subagents chip, or the inline subagent pill in the parent transcript. Opened subagent chats show their live progress, use the subagent title when available, and omit the composer and mutating chat actions so the worker transcript stays view-only.

Keyboard shortcuts for chats in the Agents window

The Agents window supports multi-chat sessions, where one agent session can contain multiple related chats. Keyboard-driven chat navigation helps you move between chats and manage chat tabs without leaving the keyboard.

• Create a chat with unassigned.
• Reopen the last closed chat with unassigned.
• Go to the next or previous chat with unassigned and unassigned.
• Quickly switch between open chats with unassigned and unassigned.
• Close the active chat tab with unassigned.
• Delete the active non-main chat with unassigned.
• Open a searchable picker for open and closed chats with unassigned.

These shortcuts are scoped to the Agents window and fall back to the existing session-level behavior when there is no chat-specific action to perform.

Chat

Copilot Vision is now generally available

Multimodal support is now generally available in VS Code, starting with this latest release. Attach images and PDFs by pasting them into Chat, dragging and dropping them, or using the context menu. Images may also be read by the agent via a tool call.

Check out this GitHub changelog for supported formats and availability details.

BYOK models in agent host Copilot sessions (Experimental)

Setting: chat.agentHost.byokModels.enabled

Use Bring Your Own Key (BYOK) models when you run sessions on an agent host. Enable chat.agentHost.byokModels.enabled and restart the agent host process for the change to take effect.

This feature is experimental and is still under active development.

Configure sampling parameters for custom endpoint models

You can configure temperature and top_p for each Custom Endpoint model, so requests work with providers that have strict parameter requirements.

Add the modelOptions object to a model's JSON configuration:

{
  ...
  "models": [
    {
      "id": "<model-id>",
      "modelOptions": {
        "temperature": 1,
        "top_p": null
      },
      ...
    }
  ]
}

Set a property to a number to override the default value that VS Code sends. Set it to null to omit the parameter from requests and use the model server's default. These options apply to Chat Completions, Responses, and Messages-compatible endpoints.

Configure the default utility model for BYOK

Setting: chat.byokUtilityModelDefault

When you use a bring your own key (BYOK) model as the main agent model, you can change the default behavior used by built-in utility flows, such as generating a chat title or a commit message. Set chat.byokUtilityModelDefault to use the main agent model, use a model provided by GitHub Copilot, or not use a default utility model.

Note: The default behavior is that no utility models are used with BYOK models as the main agent. Background tasks such as chat title generation and commit message generation do not work unless this option is set.

This setting has no effect when the main agent model is provided by GitHub Copilot. A model configured with chat.utilityModel or chat.utilitySmallModel takes precedence over this default.

Deep links to a specific chat

The Agents window helps you manage agent sessions and return to their associated workspaces and chats. Deep links can take you directly back to the relevant chat, so you don't have to open the workspace first and then manually find the session in Chat.

When an app opens a vscode:// deep link for a session, VS Code opens the workspace and focuses the specific chat identified by the link's session query parameter. The Open in VS Code action in the Agents window uses the same behavior, opening both the session's workspace folder and its active chat in the new VS Code window.

Editor Experience

Configurable placement of integrated browser tabs

Setting: workbench.browser.newTabPlacement

Keeping tabs organized can be a challenge. With this release, you can configure a location for browser tabs to open via the workbench.browser.newTabPlacement setting. The setting can take the following values:

• activeGroup (default): Browser tabs always open in the active editor group.
• sideGroup: Browser tabs open in a dedicated group to the side. This group is locked so only browser tabs open there.
• window: Browser tabs open in a dedicated auxiliary window. This window group is also locked to only browser tabs.

You can still reorganize tabs as desired, and pages opened from an existing tab (for example, by selecting a link with Ctrl) open in the same group as the parent.

OS-level keyboard shortcuts

VS Code can now contribute OS-level keyboard shortcuts. These shortcuts take effect even if VS Code is not in focus. Add systemWide to your keybinding definition in your keybindings.json to make it OS-level. For example, here's a keybinding in keybindings.json to focus the Agents window on MacOS:

{
  "key": "cmd+shift+a",
  "command": "workbench.action.openAgentsWindow",
  "systemWide": true
}

Enterprise

Manage Copilot telemetry export with OpenTelemetry

Organizations can mandate where GitHub Copilot sends OpenTelemetry (OTel) data, so that telemetry flows to an approved collector without each developer setting OTEL_* environment variables. The managed configuration applies to both the Copilot Chat extension and the agent host process.

Administrators deliver these settings through the telemetry block in Copilot managed settings, using any of the supported delivery channels. The block controls:

• The OTLP export endpoint and protocol.
• The OTel service name and resource attributes.
• Exporter headers, such as an authentication token for the collector.
• Whether prompt and response content is captured, and whether developers can change that.

A managed value always wins, taking precedence over environment variables and user settings.

To learn more, see Configure telemetry export with OpenTelemetry and Monitor agent usage with OpenTelemetry.

Thank you

Contributions to vscode:

• @accnops (Arthur Cnops): chat/voice: land voice answers on question carousels (fix Skipped) PR #323161
• @dobbydobap (varshitha): Fix second Rerun Last Task failing to launch for reevaluateOnRerun tasks PR #324571
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #321221
• @yavanosta (Dmitry Guketlev): Use startColumn in growUntilVariableBoundaries PR #324523

Issue tracking

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @jasonperry1231hou-lang (jasonperry1231hou-lang)
• @RedCMD (RedCMD)
• @luo2430 (luo2430)

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.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