Visual Studio Code

Visual Studio Code 1.131

Follow us on LinkedIn, X, Bluesky Release date: July 29, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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 , dictation.showTranscript , dictation.experimental.llmCleanup To 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. #1600: Lazy-register Conda manager, #1598: Coalesce concurrent native finder refreshes with the same key, #1607: Return last-known environment when getEnvironment times out

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.

Visual Studio Code 1.130

Follow us on LinkedIn, X, Bluesky Release date: July 22, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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 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) PR #325799
• voice: send request_narration only after session context is sent PR #325928
• voice: NACK + client revalidation for dropped narration PR #325966
• @ahmadawais (Ahmad Awais): Detect Command Code as an agent CLI for terminal tab titles PR #324417
• @AntonioLujanoLuna (Antonio Lujano Luna): Fix BYOK Anthropic endpoints sending PDFs as image blocks PR #324960
• @arham766 (Shahrier Islam Arham): chore: bump windows-process-tree to 0.8.0 to fix UTF-8 command lines in Process Explorer PR #324283
• @clintharrison (Clint Harrison): Support mnemonic prefixes in git diff parsing for terminal links PR #298490
• @justjavac (迷渡): Decorations: fall back to lower-priority colors PR #325422
• @kobihikri (Kobi Hikri): Remove dead CODEOWNERS rules for deleted no-package-lock / no-yarn-lock workflows PR #325932
• @mirimadahmed (Mir)
• Handle voice barge-in playback PR #325808
• Fix voice barge-in protocol PR #326159
• Voice agent send voice language locale from the client PR #325931
• Voice agent always on streaming mode to support barge in PR #326165
• Add scoped live Voice transcripts PR #326134
• @pony-maggie (Lucas Ma)
• Avoid stale simple dialog folder updates PR #321357
• Allow simple file dialog to create nested folders PR #321355
• @rfeltis (Ralph Feltis): Fix quota trajectory billing period calculation PR #325895
• @smorimoto (Sora Morimoto): Recognise OCaml in settings labels PR #325457
• @spokodev: fix: match uppercase query characters in fuzzyContains PR #324047
• @UditDewan (udit): Fix tunnelProtocol context key always resolving to https on focus PR #325445

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.

Visual Studio Code 1.129

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

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.

Visual Studio Code 1.128

Follow us on LinkedIn, X, Bluesky Release date: July 8, 2026 Update 1.128.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.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. This experience is available when using the Claude agent via the agent host. Ensure the agent host is enabled and can be selected for the Claude agent (via the harness picker) with chat.agentHost.enabled and chat.agents.claude.preferAgentHost .

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 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 (and selected via the harness picker) with chat.agentHost.enabled . 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. This experience is available when using Copilot via the agent host. Ensure the agent host is enabled (and selected via the harness picker) with chat.agentHost.enabled .

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 .
• Reopen the last closed chat with .
• Go to the next or previous chat with and .
• Quickly switch between open chats with and .
• Close the active chat tab with .
• Delete the active non-main chat with .
• Open a searchable picker for open and closed chats with . 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. Ensure the agent host is enabled and can be selected with chat.agentHost.enabled .

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": "", "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.

Visual Studio Code 1.127

Follow us on LinkedIn, X, Bluesky Release date: July 1, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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

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)

Setting: sessions.layout.autoCollapseSessionsSidebar 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.

Chat

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:

Language models

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. The following video shows how to remove the deprecated provider.

Integrated browser

Camera, location, devices, and more

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

Setting: workbench.browser.enableChatTools 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. …

Visual Studio Code 1.126

Follow us on LinkedIn, X, Bluesky Release date: June 24, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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.

Visual Studio Code 1.125

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

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 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 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 vscode-languageclient@10.0.0 and vscode-languageserver@10.0.0. 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.

Visual Studio Code 1.124

Follow us on LinkedIn, X, Bluesky Release date: June 10, 2026 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! 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 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 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 ⌘H (Windows, Linux 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 hover PR #312585
• @mohityadav8 (Mohit Yadav): fix(docs): correct grammar and typo issues in documentation PR #317718
• @mutl3y: fix(terminal): catch ENOPRO in getCwdResource when file:// provider absent in VS Code web PR #317780
• @sgoedecke (Sean Goedecke): Fix auto mode fallback for empty model providers PR #316174
• @SimonSiefke (Simon Siefke)
• fix: process leaks in extensionHostConnection PR #319223
• fix: memory leak in pane composite bar PR #282589
• fix: memory leak in pty host service PR #287025
• @tbogoodnews (Taylor Blair): Fix BYOK response success turn telemetry PR #319637
• @vivekjm (Vivek JM): Disable Copy Breadcrumbs Path without symbols PR #318042
• @yogeshwaran-c (Yogeshwaran C): Remove disabled toggle from the tab order PR #319693 Contributions to vscode-extension-samples:
• @fhwvtqdc2q-svg (Lloouujjiinn): Replace deprecated typescript.tsc.autoDetect setting PR #1287 Contributions to vscode-pull-request-github:
• @Malix-Labs (Malix - Alix Brunet): feat: contributes.yamlValidation PR #8761 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.

Visual Studio Code 1.123

Follow us on LinkedIn, X, Bluesky Release date: June 3, 2026 Update 1.123.1: The update addresses these security issues. Update 1.123.2: The update addresses these 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! 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

Session sync and chronicle

Setting: chat.sessionSync.enabled 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 . 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 that is run by a local agent requires access to domains that are not configured as allowed domains, the command is automatically retried inside the sandbox with unrestricted network access. After that, if it still fails, it falls back to unsandboxed execution. This allows network-dependent operations such as git fetch to finish, while keeping filesystem protections in place.

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, we focused 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. In addition to the active session, open another session next to it 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 the active session at any time. The Terminal, Files, and Changes views all operate on the currently active session, so switching the active session updates these views to reflect its state. By default, selecting a session in the sessions list replaces the active session view with the selected one. To keep a session view from being replaced, pin it with the pin action in the top right of the view. Pinned session views are never replaced—selecting another session opens it in an unpinned view instead. If every session view is pinned, the selected session opens to the side. Use the maximize action in the top right of a session view to expand it across all open session views, giving you a focused view of a single session without closing the others. 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. When you need to understand unfamiliar code, compare approaches, or learn how a library or API works, a quick chat answer isn't always enough. 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. The research agent is optimized for depth rather than speed and has read-only access, so it investigates and reports instead of changing your code. 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. This expanded context window enables you to work with significantly larger codebases and longer conversations without losing important context. The expanded context window is available when using supported models, such as Claude Opus 4.7 and GPT-5.5. Note: Larger context windows may consume more tokens per interaction, which increases AI credits usage under usage-based billing.

Integrated Browser

Favorite pages

We've remodeled the address bar in the integrated browser into a more versatile experience where you can not only enter URLs but also favorite pages and easily access your favorites and open tabs. To add a page to your favorites, select the star icon in the browser URL bar. When you select the URL bar, you can see 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, which lets you attach a screenshot of the current browser viewport to chat as context. This is especially useful for UI-related tasks, such as debugging a layout issue. This release, we added two related features:

• Add Area Screenshot to Chat: Take a screenshot of a rectangular area that you select, and add that screenshot as chat context.
• Add Full Page Screenshot to Chat (Experimental): Take a screenshot of the entire web page, even beyond what is shown in the current viewport, and add that screenshot as chat context. This experimental feature requires enabling the workbench.browser.experimentalUserTools.enabled setting.

MCP

Configure OAuth client credentials in mcp.json

Some MCP servers expect you to authenticate with a specific, pre-registered OAuth client instead of relying on Dynamic Client Registration. You can now specify a client ID directly in the oauth section of an MCP server entry in mcp.json: "my-mcp-server": { "url": "https://mcp.example.com/mcp", "type": "http", "oauth": { "clientId": "your-client-id" } } When a client ID is set, VS Code uses it during the OAuth flow instead of registering a new client, so you can bring your own pre-registered client configuration. Some MCP servers also require a client secret alongside the public client ID. You can now store a client secret in VS Code's OS-backed secret storage, where it stays encrypted instead of sitting in plaintext config. When an MCP server entry in mcp.json has an oauth.clientId, a Set Client Secret CodeLens appears above it. Selecting it lets you enter the secret, which is stored securely and scoped to the server URL and client ID (so two servers with the same name in different configs never collide). Once a secret is stored, the CodeLens flips to Replace Client Secret, and you can reveal, replace, or delete it at any time.

Enterprise-managed MCP authentication (Preview)

If your organization centralizes sign-in at a single identity provider (like Entra, Okta, or Auth0), you probably don't want every MCP server running its own Dynamic Client Registration against its own authorization server. This release adds a cross-app authorization (XAA) flow that lets you authenticate once against your enterprise IdP, and then VS Code mints a per-resource token for each MCP server on your behalf. Under the hood, VS Code exchanges your IdP identity for a resource-scoped assertion using ID-JAG (cross-app access), and then redeems that assertion at the MCP server's authorization server for an access token. The result is that users sign in a single time, and there's no per-server client registration to manage. Note: ID-JAG is still an emerging standard and isn't widely adopted yet, but we believe it's the future of cross-app authorization. To learn more about XAA and try it against a sample IdP, resource authorization server, and MCP server, see xaa.dev. There are two pieces to set this up:

• Admins configure the IdP through the policy-managed mcp.enterpriseManagedAuth.idp setting. Because it's policy-backed, it's primarily delivered through Windows Group Policy, macOS managed preferences, or Linux /etc/vscode/policy.json, and it never syncs.
• Individual MCP servers opt in to the flow by setting "enterpriseManaged": true in their oauth block in mcp.json. When that flag is present, VS Code routes the server through the XAA provider instead of the standard per-server registration path.

Editor Experience

Delayed extension auto-updates

VS Code now applies a two-hour delay before automatically updating extensions to a newly published version. When automatic updates are enabled, new versions are auto-updated two hours after they are published, adding an extra layer of protection against problematic or potentially compromised releases. This never gets in your way, as you can still update any extension immediately at any time by using the Update button. While an update is waiting, the extension's details view explains why it hasn't updated yet and when the automatic update will happen. Note: This delay does not apply to extensions from trusted publishers such as Microsoft, GitHub, and OpenAI. These extensions continue to update immediately.

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

Visual Studio Code 1.122

Follow us on LinkedIn, X, Bluesky Release date: May 28, 2026 Update 1.122.1: The update addresses these issues. Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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.

• Larger context windows: Support for 1M context windows for Anthropic and OpenAI models.
• 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! 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.

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

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

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. This expanded context window enables you to work with significantly larger codebases and longer conversations without losing important context. The expanded context window is available when using supported models, such as Claude Opus 4.7 and GPT-5.5. Note: Larger context windows may consume more tokens per interaction, which increases AI credits usage under usage-based billing.

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.

Visual Studio Code 1.121

Follow us on LinkedIn, X, Bluesky Release date: May 20, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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! 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

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

Settings: 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. …

Visual Studio Code 1.120

Follow us on LinkedIn, X, Bluesky Release date: May 13, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap 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! 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

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. "extensions.supportAgentsWindow": { "myextension.id": true } 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: "workbench.diffEditorAssociations": { "*.md": "vscode.markdown.preview.editor" } 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.

Visual Studio Code 1.119

Follow us on LinkedIn, X, Bluesky Release date: May 6, 2026 Update 1.119.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.119 release of Visual Studio Code. This release focuses on smoother agent interactions, enhanced observability, and more efficient trust and security controls.

• Agent-browser interaction: Let agents discover and ask for integrated browser access.
• Optimized token usage: Use a lightweight model to manage agent todo lists.
• OpenTelemetry tracing: Monitor agent sessions with OpenTelemetry.
• Trust and developer efficiency: Get less interrupted by requests for network access or temp folder writes.
• Markdown preview: Quickly switch between Markdown source and preview. Happy Coding! VS Code is rolling out gradually to all users. Use Check for Updates in VS Code to get the latest version immediately. To try new features as soon as possible, download the nightly Insiders build, which includes the latest updates as soon as they are available.

Agent experience

Sharing browser tabs with agents

When agents can access a live browser, they validate changes in real time and iterate faster. For web development, an agent can edit code, reload the page, and confirm the fix in a single turn. For design workflows, the agent can compare rendered output against your intent and refine layout or styling on the fly. Get started with using the integrated browser with agents in VS Code. An agent does not automatically have access to the integrated browser. You need to explicitly share browser pages with the agent for it to interact with them. This helps keep sensitive data private. In this release, we've added new ways to share browsers with an agent:

Attach browser tabs as context

Browser tabs can now be explicitly attached to the chat via typical entry points such as suggested context, context picker, and drag-and-drop actions. When a browser tab is attached, it enters a sharing state where the agent can read and interact with the page. Use the sharing button in the browser to stop sharing when you're done.

Agents-initiated requests to share a page

Agents now have information about how many browser tabs you have open and are not shared. They can request to share an open tab when they need to interact with a page, and you can approve or deny the request in a prompt. When an agent tries to open a new tab on the same domain as an existing, unshared tab, a prompt appears to ask if you want to reuse the existing tab. This aims to encourage tab reuse and reduce clutter.

Visual Studio Code Agents (Insiders)

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

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

OpenTelemetry tracing for agent sessions

Settings: github.copilot.chat.otel.enabled , github.copilot.chat.otel.otlpEndpoint As agent sessions grow longer and more autonomous, understanding what the agent did, how long each step took, and where tokens were spent becomes essential for optimizing cost and debugging unexpected behavior. OpenTelemetry is the industry-standard observability framework. Copilot Chat agent sessions, including the local agent, the Copilot CLI background agent, and the Claude agent, now emit OpenTelemetry traces, metrics, and events that follow the GenAI semantic conventions, so you can monitor agent behavior, latency, and token usage in any OTLP-compatible backend (for example, the Aspire Dashboard). Each user request produces an invoke_agent root span (for example, invoke_agent claude) with nested chat, execute_tool, and execute_hook child spans. Subagent invocations are automatically parented to the calling agent's execute_tool span, giving you full visibility into the agent's work in a single connected trace. Spans report model and token usage, including cache read and cache creation breakdowns. To try it out, enable github.copilot.chat.otel.enabled and point github.copilot.chat.otel.otlpEndpoint to your collector. Learn how to monitor agent usage with OpenTelemetry in the VS Code documentation.

Chat experience

Show model details for Copilot CLI and Claude agent responses

Setting: github.copilot.chat.agent.modelDetails.enabled Knowing which model handled a response and how it counts against your usage helps you stay in control of cost and quality. Copilot CLI and Claude agent responses in the Chat view now show the model and its multiplier on each response. The badge appears live as each response completes, without needing to reload the window, and updates when you switch models mid-session. When you use Auto model selection in Copilot CLI, the badge displays the actual model that was used (for example, Claude Sonnet 4.6) instead of auto. The resolved model is also preserved when the session is rebuilt from history. The behavior is enabled by default. To turn off the badge, disable the github.copilot.chat.agent.modelDetails.enabled setting and reload the window.

Optimized token usage for managing todo lists (Experimental)

Setting: github.copilot.chat.agent.backgroundTodoAgent.enabled Todo lists help an agent stay on track during complex, multi-step tasks by giving it an explicit record of what's been done and what comes next. However, every tool call the main model makes to update a todo list costs tokens, and those costs add up across long sessions. By offloading todo list management to a lightweight background agent, the main model can focus on the actual task while a smaller model keeps progress tracking in sync. This reduces overall token usage without sacrificing the guidance that keeps the agent focused. When this setting is enabled, the background agent monitors main agent activity and updates the todo list to reflect completed and in-progress work. The main agent will not have the todo tool available, thus saving token cost for the conversations. Note: If the todo tool is manually added to the chat request (for example with #todo), or a custom agent specifies it in its tool list, the background agent is overridden and does not run. This feature is disabled by default. To try it out, enable the github.copilot.chat.agent.backgroundTodoAgent.enabled setting.

Usage-based billing updates

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

Trust and Security

Allow network access in agent sandboxes

Setting: chat.agent.sandbox.enabled Agent sandboxing protects your system by restricting what agent tools can access, but strict network blocking can get in the way when agents need to install packages, call APIs, or run dev servers. The chat.agent.sandbox.enabled setting now has an allowNetwork mode that keeps file system restrictions in place while removing network domain blocking, so you get sandbox protection without constant interruptions for network access. "chat.agent.sandbox.enabled": "allowNetwork" When network access is allowed for the sandbox, the chat.agent.allowedNetworkDomains and chat.agent.deniedNetworkDomains settings are ignored. Learn more about agent sandboxing in the VS Code documentation.

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

Setting: chat.tools.terminal.blockDetectedFileWrites Frequent approval prompts for routine file writes can slow down agent workflows. When chat.tools.terminal.blockDetectedFileWrites is set to its default value of outsideWorkspace, terminal commands that write outside your workspace require approval, even if you selected Allow All Commands in Session. Writes to the operating system temporary folder (/tmp on macOS and Linux, %TEMP% on Windows) are now exempt from this check when Allow All Commands in Session is active. This means that common agent workflows that stage scratch files in the temp folder no longer interrupt the session, while writes to other locations outside the workspace still require confirmation.

Languages

Swap current editor to Markdown preview

We've made it easier to switch the current editor back and forth to the Markdown preview. VS Code has had this functionality for a while, but it was often overlooked. These new buttons and commands make it much more discoverable. In a Markdown file, select this button in the toolbar or run the Markdown: Switch to Preview View command. With the preview opened, you can select the Switch to Editor View button or command to swap back to the source code view.

Reorganized Markdown settings

To help you discover and manage settings for VS Code's built-in Markdown support, we've created a few basic groups for them in the Settings editor under Extensions > Markdown Language Features. All setting IDs remain the same but now all the settings related to the built-in Markdown preview are listed under the Preview subsection.

Engineering

Finished migrating webviews to use CSS anchor positioning

VS Code's webviews now use anchor positioning to position themselves visually in the workbench. This improves performance and makes relayouts more responsive, especially if there are many active webviews. It also let us fix some tricky, long-standing bugs, such as webviews going out of position on web when the workbench was moved. Here's a typical relayout call for a single webview before the switch to anchor based positioning: Positioning the webview here was done using JS, which called getBoundingClientRect. This call ends up being relatively slow because it triggers browser style recalculations and relayouts. By moving to anchor based positioning, the browser now handles positioning the webview for us based on the CSS.

Typechecking now uses TypeScript 7 for faster development iteration

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

Visual Studio Code 1.118

Follow us on LinkedIn, X, Bluesky Release date: April 29, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap Welcome to the 1.118 release of Visual Studio Code. This release expands where you can work with Copilot agents and makes them more efficient. Here are the highlights for this release:

• Remote control: Track and control your ongoing Copilot CLI sessions remotely from GitHub.com or mobile.
• Codebase search: Find the code you need with semantic search in any workspace and text search across GitHub repos and orgs.
• Dedicated context for skills: Isolate skill execution to keep your main chat focused and answers sharper.
• Chat session insights: Turn your chat history into standup reports, tips, and answers about past work.
• Enterprise control: Restrict AI feature access to organizations your admin trusts.
• Improved token efficiency: Get more out of every request with lower token usage. Happy Coding! VS Code is rolling out gradually to all users. Use Check for Updates in VS Code to get the latest version immediately. To try new features as soon as possible, download the nightly Insiders build, which includes the latest updates as soon as they are available.

Agent experience

Visual Studio Code Agents (Insiders)

Note: The Visual Studio Code Agents app is currently in preview and only available when installing VS Code Insiders. The Visual Studio Code Agents app is a companion app that ships alongside VS Code Insiders. It provides a focused, agent-native environment where you can run parallel sessions across repos and iterate on multi-step coding tasks. We first introduced the Agents app in 1.115 and continue to refine it based on user feedback. In this release, you can discover the Agents app directly from the VS Code Insiders title bar, making it easy to jump into an agent-powered workflow. We also published dedicated Agents documentation to help you get started. Recent feature highlights include:

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

Remote control for Copilot CLI sessions (Experimental)

Setting: github.copilot.chat.cli.remote.enabled Previously, to engage with a Copilot CLI session, you had to be at the machine where you started it. If the agent paused for an approval or hit a question while you were away from your desk, the work stalled until you returned. With remote control, you can monitor and steer your ongoing Copilot CLI sessions from anywhere, giving you more flexibility to keep work moving without being tied to your machine. Remote control for Copilot CLI lets you check progress, respond to approvals, and steer work from another device (using GitHub.com or the GitHub mobile app), while your Copilot CLI session keeps running in the background. To try remote control:

• Enable the github.copilot.chat.cli.remote.enabled setting.
• Enter /remote on in a Copilot CLI chat to get started. You can always run /remote to view remote control status, or /remote off to disable remote control.

Synced session titles for Copilot CLI

The chat session title is used across different chat surfaces like the chat sessions list, the chat editor tab and header, and the Copilot CLI terminal interface to provide a consistent identifier for the session. Depending on where you renamed a Copilot CLI session, other chat surfaces could still show the old title. VS Code adopts the Copilot SDK session title APIs as the source of truth and routes the sessions list and chat editor header through a single title resolver to keep the displayed title consistent across surfaces. The chat sessions list, the chat editor tab and header, and copilot --resume in the terminal now all stay in sync when you rename a session, regardless of where the rename originated. Renames performed in the terminal from Copilot CLI are also picked up by VS Code the next time the session metadata is read.

Copilot added as a Git co-author by default

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

Codebase search and context

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

When you ask Copilot a question like "where do we handle user authentication?", the agent has to translate your fuzzy intent into the exact files and symbols that matter. Plain text search only matches the literal words you typed, so it often misses the relevant code when your codebase uses different terminology. Semantic indexing lets agents search by meaning, surfacing files that use related terms like login, signIn, verifyCredentials, or OAuth token exchange, even if the word "authentication" never appears in the code. This gives the agent better grounding for answers and edits. Semantic indexing is now available in all workspaces. Previously, this capability was limited to workspaces that use GitHub or ADO repositories. The semantic index is built and maintained automatically. Workspaces that use a GitHub or ADO repository can typically use semantic search instantly, while other workspaces might require a few minutes to build up the initial index. You can also use the Build Codebase semantic index command to explicitly build the index for the current workspace. Semantic search is one of the many tools Copilot uses to understand your workspace when answering questions and generating edits. Copilot will pick the best tools for the job, so you generally do not have to micromanage how it searches. Check out the How Copilot understands your workspace docs for more details on semantic search and the other tools that Copilot uses.

GitHub text search across repos or orgs

When the agent needs to look up an exact string, API name, or error message in code outside your current workspace, semantic search isn't always the right fit. You want a precise match across a known repository or your entire organization, not a fuzzy one. To support this, Copilot now includes a built-in githubTextSearch agent tool that does a grep-style search through the code of a GitHub repository or an entire GitHub organization. This complements the existing githubRepo tool, which does semantic searches within a GitHub repo. Together, these tools give the agent a richer way to learn from codebases outside the one you are currently working on. For more advanced GitHub features such as searching and managing issues or pull requests, consider using the GitHub MCP server.

Dedicated context for skills (Experimental)

Setting: github.copilot.chat.skillTool.enabled When you use a skill that performs multi-step tool calls or pulls in large reference material, that auxiliary content can crowd your main chat context and degrade the quality of follow-up responses. You can now run a skill in a dedicated subagent context that isolates its execution from the main conversation, so your primary context stays focused and skill responses remain higher quality. To run a skill in a dedicated subagent context, set the context attribute in the SKILL.md frontmatter: --- name: my-skill description: My skill description context: fork --- This feature is experimental and requires the github.copilot.chat.skillTool.enabled setting to be enabled.

Workspace .mcp.json files and server deduplication

We've added support for workspace-level .mcp.json files to declare MCP servers, aligning with other tools such as the Copilot CLI. Additionally, we've introduced behavior to deduplicate MCP servers that share the same name. By default, only the most-specific MCP server will be enabled, and enabling a server will disable other servers by the same name. You can control which MCP servers are enabled by searching @mcp @installed in the extensions view, or via the Chat: Open Customizations window.

Improving token efficiency

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

Prompt caching efficiency

Over the past several iterations, we have improved cache reuse across system prompts, tools, conversation history, and summarization, without changing how the agent behaves. In practice, this means repeated context is billed at a much lower token rate (for example, about 10x lower for Anthropic models), which helps reduce cost in longer, multi-turn agent workflows. Strategic cache breakpoint placement. We audited where cache breakpoints are set so they are used efficiently and placed at stable boundaries: end of system prompt, end of tools, end of the most recent tool turn, and conversation turn boundaries. As a result, once an agent session is underway, more than 93% of each request is reused from cache instead of being charged as new input. A cache-stable system prompt and tools list. A cached prefix is only as good as the bytes that precede it. We reviewed the system prompt and tool registration paths to remove sources of byte drift across requests. For example, the new chat.experimental.symbolTools.cacheStable registers vscode_renameSymbol and vscode_listCodeUsages with a static description instead of one that changes based on which languages are loaded. That way, when a language extension activates partway through a session, it no longer changes the request and resets the cache. We also re-ordered the tools list so deferred and non-deferred tools are grouped predictably, keeping the tools-array bytes identical across turns. Cache-friendly background compaction. As a session gets long, we summarize older turns in the background so the agent can keep working without running out of context. The model can still look up tool results and details from earlier turns when it needs them. These background summaries now reuse the same cached context as the main agent, making long, multi-turn sessions noticeably more efficient. …

Visual Studio Code 1.117

Follow us on LinkedIn, X, Bluesky Release date: April 22, 2026 Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap Welcome to the 1.117 release of Visual Studio Code. This release adds new capabilities for Copilot Enterprise and Business users and further improves the agent experience in VS Code. Here are the highlights for this release:

• BYOK for Business and Enterprise: Connect your own API keys for preferred or specialized models directly in VS Code chat.
• Incremental chat rendering: Experience more fluid streaming of chat responses.
• Terminal improvements: Launch Copilot CLI from any terminal profile. Happy Coding! 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.

Bring your own key for Copilot Business and Enterprise

Teams often need specific models for compliance, performance, or cost reasons, but switching between tools to use them slows developers down. Bring your own language model key (BYOK) lets Copilot Business and Enterprise users connect their own API keys for providers like OpenRouter, Ollama, Google, OpenAI, and more, so they can use those models directly in VS Code chat. By default, BYOK is enabled and administrators can disable it with the Bring Your Own Language Model Key policy in the Copilot policy settings on GitHub.com. This gives administrators control over which model providers are available to their organization while keeping developers in their existing workflow. After the policy is enabled, organization members can add models from built-in providers or install language model provider extensions.

Chat experience

Incremental rendering of chat responses (Experimental)

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

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

Sort agent sessions by recent activity

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

System notifications for background terminal commands

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

Agent experience

Visual Studio Code Agents (Insiders)

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

• Create sub-sessions: Select + in the session title to spawn a sub-session from the current session. This is handy for starting additional work in context, such as parallel research or a code review, without losing your place in the parent session.
• Inline change rendering: Improvements to how changes are rendered inline make it easier to scan and compare diffs when the agent edits your code.
• Update experience: Improvements to the update flow across operating systems make it smoother to stay on the latest version.
• Theming, chat response, and UX polish: Continued refinements to theming, session list and response rendering, and overall UX across the app. As in previous releases, you can open the app via the same methods:
• Launch Visual Studio Code Agents - Insiders from your Start menu or Applications folder in the OS.
• Run Chat: Open Agents Application from the VS Code Insiders Command Palette.
• Select Try out the new Agents app from the VS Code Insiders welcome page.

Terminal

Launch Copilot CLI with a custom terminal profile

The Copilot CLI terminal profile can now be launched from the terminal panel, even when your default terminal profile is set to a non-default shell, such as fish on macOS or Linux, or Git Bash on Windows. Previously, selecting GitHub Copilot CLI from the terminal profile picker in this configuration produced a No terminal profile options provided for id 'copilot-cli' error and the terminal failed to start.

Terminal title for agent CLIs

Agent CLIs like Copilot CLI, Claude Code, and Gemini CLI typically run as node processes, which meant the terminal title showed a generic node label. This made it hard to tell which agent was running in each terminal. The terminal now detects these agent CLIs as a distinct shell type and uses the OSC title sequence emitted by the CLI as the terminal title, so each terminal clearly identifies the agent it is hosting. The improved detection covers Copilot CLI, Claude Code, and Gemini CLI on macOS, Linux, and Windows. Codex is not yet detected on macOS because it does not currently emit an OSC title sequence. This behavior is enabled by default and can be toggled with the terminal.integrated.tabs.allowAgentCliTitle setting.

Languages

TypeScript 6.0.3

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

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Thank you

Contributions to our issue tracking:

• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini) Contributions to vscode:
• @abadawi591 (abadawi-msft): Abadawi/send has image to router PR #308321
• @andysharman: fix: default session mode experiment not applying on first session PR #308905
• @bocan (Chris Funderburg): Fix crash on null entries in launch.json configurations array PR #308235
• @jamestut (James Nugraha): await openEditor in terminal editor split to prevent shadow tab PR #309167
• @maruthang (Maruthan G)
• fix(tasks): add hover description for required property in taskDefinitions contribution schema (#_275670) PR #310764
• fix(debug): identify instruction breakpoints by resolved address to allow removal when instructionReference changes (#_289678) PR #310763
• fix(terminal-chat): dedupe terminal tool-session registrations to prevent listener leak (#_309906) PR #310740
• fix(chat): guard renderWelcomeViewContentIfNeeded against undisposed input part (#_310356) PR #310822
• fix: prevent listener leak from duplicate status IDs in language status (#_309042) PR #309159
• fix(chat): cancel in-flight streaming tool invocations when response is cancelled (#_288701) PR #310979
• @matts1 (Matt): feat: Support switching to the main window. PR #306573
• @NikolaRHristov (Nikola Hristov): fix: make protected members public to resolve mangler build errors PR #310195
• @OscarPalafox (Oscar Palafox Verna): Consistent include pathing for new 2026 in theme-defaults PR #309880
• @RieBi (Sviatoslav Zubar): Additionaly to newest published version of package also show currently installed version PR #308569
• @yogeshwaran-c (Yogeshwaran C)
• json: fix language model cache evicting at capacity instead of overflow PR #309176
• Do not open debug view on first session start when openDebug is openOnDebugBreak PR #309133
• testing: align right-click menu with hover bar on compressed result rows PR #309139
• Adopt CodeAction type for built-in css server PR #310055 We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new. If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.