Visual Studio Code Updates & Release Notes

Welcome to the 1.121 release of Visual Studio Code

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

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

Happy Coding!

Agents

Agents Window (Preview)

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

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

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

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

Remote agents (Preview)

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

Connecting to a remote

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

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

How it works

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

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

Agent Host Protocol

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

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

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

Agents observability with OpenTelemetry and Grafana

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

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

Claude agent Auto permission mode (Preview)

Setting: github.copilot.chat.claudeAgent.allowAutoPermissions

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

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

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

Language Models

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

Configure utility models

Setting: chat.utilityModel, chat.utilitySmallModel

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

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

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

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

Custom Endpoint provider for BYOK (Insiders)

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

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

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

Integrated Browser

Quickly open HTML files in the Integrated Browser

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

Improved experience for adding elements to chat

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

Select a range of elements

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

Attach elements from context menus

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

Terminal

Agent-aware terminal commands

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

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

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

Running in background indicator for terminal tools

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

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

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

Cleanup of background agent terminals

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

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

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

Broader compression for terminal tool output

Setting: chat.tools.compressOutput.enabled

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

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

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

Sensitive terminal prompts stay in the terminal

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

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

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

Editor

Quick suggestions default setting change

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

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

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

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

Languages

Mermaid diagrams in Markdown preview and Notebooks

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

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

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

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

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

YAML frontmatter in Markdown preview

Setting: markdown.preview.frontMatter

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

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

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

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

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

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

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

Original source

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

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

Happy Coding!

Agents

Orchestrate tasks across projects with the Agents window (Preview)

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

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

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

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

What's new?

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

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

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

Extensibility

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

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

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

Discover Copilot CLI plugins automatically

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

Language models

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

View BYOK model token usage

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

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

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

Configure thinking effort for BYOK reasoning models

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

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

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

Model picker organized by provider

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

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

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

Chat

Terminal tool output compression (Preview)

Setting: chat.tools.compressOutput.enabled

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

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

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

Risk assessment for terminal commands (Experimental)

Setting: chat.tools.riskAssessment.enabled

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

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

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

Plan mode control for Claude and Copilot CLI

Setting: chat.planWidget.inlineEditor.enabled

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

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

Languages

Markdown preview for diffs (Preview)

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

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

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

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

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

Markdown preview default changes

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

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

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

HTML id support for Markdown path completions and validation

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

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

Smart select for Markdown tables

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

Proposed APIs

Custom editor diffs

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

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

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

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

Separate custom editor priorities diffs and merges

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

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

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

Document diff

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

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

Track progress and provide feedback in issue #315174.

Contributions to extensions

GitHub Pull Requests

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

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

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

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Notable fixes

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

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

Contributions to vscode-pull-request-github:

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

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

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

Original source

Welcome to the 1.119 release of Visual Studio Code.

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

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

Happy Coding!

Agent experience

Sharing browser tabs with agents

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

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

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

Attach browser tabs as context

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

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

Agents-initiated requests to share a page

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

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

Visual Studio Code Agents (Insiders)

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

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

Updates in this release include:

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

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

OpenTelemetry tracing for agent sessions

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

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

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

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

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

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

Chat experience

Show model details for Copilot CLI and Claude agent responses

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

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

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

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

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

Optimized token usage for managing todo lists (Experimental)

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

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

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

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

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

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

Usage-based billing updates

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

Trust and Security

Allow network access in agent sandboxes

Setting: chat.agent.sandbox.enabled

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

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

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

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

Learn more about agent sandboxing in the VS Code documentation.

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

Setting: chat.tools.terminal.blockDetectedFileWrites

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

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

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

Languages

Swap current editor to Markdown preview

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

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

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

Reorganized Markdown settings

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

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

Engineering

Finished migrating webviews to use CSS anchor positioning

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

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

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

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

Typechecking now uses TypeScript 7 for faster development iteration

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting is managed at the organization level. Contact your administrator to change it. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

Contributions to vscode-pull-request-github:

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

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

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

Original source

Welcome to the 1.118 release of Visual Studio Code.

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

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

Happy Coding!

Agent experience

Visual Studio Code Agents (Insiders)

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

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

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

Recent feature highlights include:

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

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

Remote control for Copilot CLI sessions (Experimental)

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

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

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

To try remote control:

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

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

Synced session titles for Copilot CLI

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

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

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

Copilot added as a Git co-author by default

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

You can change the default behavior using git.addAICoAuthor.

Codebase search and context

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

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

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

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

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

GitHub text search across repos or orgs

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

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

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

Dedicated context for skills (Experimental)

Setting: github.copilot.chat.skillTool.enabled

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

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

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

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

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

Workspace .mcp.json files and server deduplication

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

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

Improving token efficiency

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

Prompt caching efficiency

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

Strategic cache breakpoint placement.

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

A cache-stable system prompt and tools list.

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

Cache-friendly background compaction.

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

Last-two-messages breakpoint strategy.

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

Tool search tool

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

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

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

New tools for search and execution

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

Agentic search tool

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

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

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

Agentic execution tool

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

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

Chat performance and history

WebSockets supported for OpenAI models

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

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

Chronicle (Experimental)

Setting: github.copilot.chat.localIndex.enabled

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

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

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

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

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

Trust and security

Approved account organizations policy

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

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

Learn more about enterprise policies.

Sandboxing default read permissions

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

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

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

Accessibility

Keyboard shortcut to focus terminal from question carousel

Setting: accessibility.verbosity.chatQuestionCarousel

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

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

Editor Experience

Optimized loading of large local resources in webviews

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

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

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

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

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

Languages

TypeScript 7.0 Beta support

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

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

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

Contributions to extensions

Chat Customizations Evaluation extension

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

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

Remote Development

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

Dev Container lockfile for Features enabled by default

Setting: dev.containers.lockfile

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

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

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

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

Engineering

Faster development builds with TypeScript 7

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting is managed at the organization level. Contact your administrator to change it. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

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

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

Original source

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

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

Happy Coding!

Bring your own key for Copilot Business and Enterprise

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

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

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

Chat experience

Incremental rendering of chat responses (Experimental)

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

Configure incremental response rendering with the following settings:

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

Sort agent sessions by recent activity

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

System notifications for background terminal commands

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

Agent experience

Visual Studio Code Agents (Insiders)

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

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

Updates in this release:

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

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

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

Terminal

Launch Copilot CLI with a custom terminal profile

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

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

Terminal title for agent CLIs

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

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

Languages

TypeScript 6.0.3

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

Deprecated features and settings

New deprecations in this release

Upcoming deprecations

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

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

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

Original source

Welcome to the 1.116 release of Visual Studio Code

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

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

Happy Coding!

Agent experience

Debug previous agent sessions

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

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

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

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

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

Configure thinking effort in Copilot CLI

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

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

Learn more about thinking effort and reasoning in the documentation.

Customizations welcome page

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

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

Learn more about customizing agents in the agent customization documentation.

Tool confirmation carousel (Experimental)

Setting: chat.tools.confirmationCarousel.enabled

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

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

Visual Studio Code Agents (Insiders)

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

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

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

Some of the latest updates include:

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

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

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

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

Terminal tools

Foreground terminal support for agent tools

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

Terminal input improvements

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

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

Background terminal notifications enabled by default

Setting: chat.tools.terminal.backgroundNotifications

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

Chat UX

This release includes a few UX improvements to chat:

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

Accessibility

Agents app accessibility

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

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

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

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

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

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

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

Screen reader instructions for keyboard shortcuts search results

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

Integrated browser

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

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

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

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

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

Languages

JS/TS Chat Features extension (Preview)

Setting: jsts-chat-features.skills.enabled

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

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

Engineering

GitHub Copilot is now built-in

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

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

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

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

Enterprise

Group policy to filter agent network access

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

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

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

These policies are configured with keys ChatAgentNetworkFilter, ChatAgentAllowedNetworkDomains, and ChatAgentDeniedNetworkDomains. Learn more about enterprise policies in the documentation.

Contributions to extensions

GitHub Pull Requests

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

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

• Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden This setting is managed at the organization level. Contact your administrator to change it. . This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

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

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

Original source

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

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

Happy Coding!

Visual Studio Code Agents (Preview)

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

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

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

Integrated browser

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

Browser agent tools improvements

Setting: workbench.browser.enableChatTools

Better tool labels

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

Old:

New:

Long-running script support

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

Fewer duplicate tabs

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

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

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

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

Terminal tools improvements

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

Send input to background terminals

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

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

Background terminal notifications (Experimental)

Setting: chat.tools.terminal.backgroundNotifications

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

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

GitHub Copilot

Bring your own key for Copilot Business and Enterprise

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

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

Notable fixes

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

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

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

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

Original source

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

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

Happy Coding!

Chat experience

Preview videos in the image carousel

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

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

The viewer includes:

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

Copy final response in chat

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

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

Workspace search simplification

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

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

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

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

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

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

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

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

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

For more details, see the workspace guide.

Troubleshoot previous chat sessions (Preview)

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

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

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

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

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

Languages

TypeScript 6.0

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

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

Python

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

Enterprise

Group policy to disable Claude agent

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

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

Contributions to extensions

GitHub Pull Requests

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

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

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

Proposed APIs

Fine-grained tool approval

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

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

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

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

Notable fixes

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

Thank you

Contributions to our issue tracking:

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

Contributions to vscode:

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

Contributions to vscode-pull-request-github:

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

Contributions to monaco-editor:

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

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

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

Original source

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

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

Happy Coding!

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

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

Agent experience

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

MCP support in Copilot CLI & Claude agents

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

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

Learn more about using MCP servers in VS Code.

Forking sessions in Copilot CLI & Claude agents

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

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

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

Learn more about forking a chat session in the documentation.

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

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

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

Claude session listing powered by SDK APIs

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

Nested subagents

Setting: chat.subagents.allowInvocationsFromSubagents

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

Learn more about using subagents in the documentation.

Manage plugin marketplaces

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

Learn more about using agent plugins in the documentation.

URL handlers for plugin installation

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

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

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

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

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

Chat experience

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

Chat Customizations editor (Preview)

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

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

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

Learn more about the Chat Customizations editor in the documentation.

Configurable thinking effort in model picker

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

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

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

Learn more about thinking effort and reasoning in the documentation.

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

Images preview for chat attachments

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

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

The viewer opens as a modal overlay and supports:

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

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

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

Editor experience

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

Use self-signed certificates in the integrated browser

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

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

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

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

Learn more about the integrated browser in the documentation.

Improved browser tab management

Setting: workbench.browser.showInTitleBar

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

• Quick Open Browser Tab

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

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

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

• Close All Browser Tabs

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

New default themes

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

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

Thank you

Issue tracking

Contributions to our issue tracking:

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

Contributions to vscode:

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

Contributions to vscode-copilot-chat:

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

Contributions to vscode-python-environments:

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

Contributions to vscode-windows-process-tree:

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

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

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

Original source

Visual Studio Code 1.112

Release date: March 18, 2026

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

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

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

Happy Coding!

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

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

Agent experience

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

• Message steering and queueing in Copilot CLI

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

• Preview changes before delegating to Copilot CLI

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

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

• Clickable file links in Copilot CLI terminal output

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

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

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

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

• Permissions levels in Copilot CLI

  Setting: chat.autopilot.enabled

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

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

• Troubleshoot agent behavior with /troubleshoot (Preview)

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

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

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

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

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

• Export and import agent debug logs (Preview)

  Setting: github.copilot.chat.agentDebugLog.enabled

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

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

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

• Image and binary file support for agents

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

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

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

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

  Note: The image carousel is currently experimental.

• Automatic symbol references

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

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

• Agent extensibility

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

• Customizations discovery in parent repositories

  Setting: chat.useCustomizationsInParentRepositories

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

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

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

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

• Sandbox locally running MCP servers

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

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

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

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

• Improved UI for MCP elicitation

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

• Enable or disable plugins and MCP servers

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

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

• Automatic plugin updates

  Setting: extensions.autoCheckUpdates

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

Developer experience

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

• Integrated browser

  Debug web apps with the integrated browser

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

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

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

• Integrated browser UX improvements

  Setting: workbench.browser.pageZoom

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

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

• Auto-close Find dialog after search

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

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

Terminal

• Improved IME composition for the terminal

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

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

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

Notable fixes

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

Thank you

Issue tracking

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

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

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

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

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

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

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

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

Original source

Visual Studio Code 1.111

Release date: March 9, 2026

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

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

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

Happy Coding!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

Autopilot and agent permissions

Setting: chat.autopilot.enabled

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

You can choose from the following permission levels:

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

Autopilot (Preview)

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

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

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

Learn more about Autopilot and agent permissions in our documentation.

Agent scoped hooks (Preview)

Setting: chat.useCustomAgentHooks

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

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

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

Debug events snapshot

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

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

Learn more about Debugging chat interactions in our documentation.

Chat tip improvements

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

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

Additional chat tip improvements include:

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

AI CLI profile group in terminal dropdown (Experimental)

Setting: terminal.integrated.experimental.aiProfileGrouping

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

Extension authoring

Basic IntelliSense for localized strings in extension package.json files

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

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

Engineering

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

Test plan item creation

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

Verification step generation

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

Automatic PR media attachment to linked issues

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

Chat showcase pipeline

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

Deprecated features and settings

New deprecations in this release

None

Upcoming deprecations

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

Notable fixes

Thank you

Contributions to vscode :

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

Contributions to vscode-copilot-chat :

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

Contributions to language-server-protocol :

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

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

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

Original source

February 2026 (version 1.110)

Release date: March 4, 2026

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

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

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

Happy Coding!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

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

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

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

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

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

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

More improvements are planned. Share your feedback on GitHub!

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Learn more about agent plugins in the agent plugins documentation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Learn more about context compaction in the documentation.

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

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

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

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

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

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

There are two ways to fork a session:

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

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

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

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

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

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

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

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

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

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

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

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

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

This setting lets you personalize the chat loading experience.

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

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

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

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

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

Inline chat hover mode
Setting: inlineChat.renderMode

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

Inline chat affordance
Setting: inlineChat.affordance

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Checkmarks in chat
Settings: accessibility.chat.showCheckmarks

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

Editor Experience

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

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

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

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

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

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

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

Configurable notification position
Setting: workbench.notifications.position

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

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

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

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

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

Code Editing

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

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

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

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

Source Control

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

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

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

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

Debugging

JavaScript Debugger

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

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

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

Terminal

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

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

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

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

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

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

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

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

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

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

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

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

Languages

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

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

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

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

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

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

Python

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

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

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

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

Contributions to extensions

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

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

Extension Authoring

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

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

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

Proposed APIs

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

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

Engineering

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

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

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

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

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

Deprecated features and settings

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

Upcoming deprecations
None

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

Thank you

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

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

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

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

Original source

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

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

Original source

Release date: February 4, 2026

Update 1.109.1

The update addresses these security issues.

Update 1.109.2

The update addresses an issue with chat.

Update 1.109.3

The update addresses these issues and introduces several notable features:

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

Update 1.109.4

The update addresses these issues.

Update 1.109.5

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

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

Downloads

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

Welcome to the January 2026 release of Visual Studio Code

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

Highlights include:

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

Happy Coding!

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

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

Original source

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

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

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

Happy Coding!

January 11, 2026

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

January 8, 2026

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

January 7, 2026

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

December 28, 2025

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

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

Original source