Visual Studio Code Updates & Release Notes

Follow

66 updates curated from 28 sources by the Releasebot Team. Last updated: Nov 19, 2026

Get this feed:
  • Nov 18, 2026
    • Date parsed from source:
      Nov 18, 2026
    • First seen by Releasebot:
      Nov 19, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.147

    Visual Studio Code adds a more flexible AI agent experience with scheduled requests, saved drafts, model routing, browser access, and visual responses. The release also improves automations, permissions, remote sessions, Markdown editing, and enterprise controls.

    Release highlights Have a task in mind but not ready to send it? This week, save requests as drafts or schedule them for later. When you're ready, let a model router match the task to your preferred model. And when a result is easier to show than explain, ask for a chart or mockup. • Send later (Experimental): Schedule local agent requests and follow-ups for later in the Agents window. • Browser integration (Preview): Let agents control your default browser, and preview remote HTML files without copying them to your machine. • Draft requests (Experimental): Keep multiple unsent requests with their context and configuration in the Agents window, ready to send when you are. • Customize assisted permissions: Tell the permission reviewer which actions you consider safe and which should need your approval. • Visual chat responses: Review reports, mockups, and charts inline in the Agents window with HTML previews and experimental native visuals. • Model routers (Experimental): Let a model router choose from your preferred models for different tasks. Happy coding! Already installed? Use Check for Updates in VS Code. For upcoming features, use the Insiders build. Agent sessions Send Later for chat requests (Experimental) Setting: sessions.sendLater.enabled (Agents window only) Sometimes you want an agent to run a request after some time has passed. You might want to check a build after it finishes, or follow up on a review in the morning. With the Send Later feature, you can postpone sending a chat request until a specific time. You can schedule a chat request by using the Send Later menu on the send button in chat. For a specific time, select Choose Date and Time, pick a day in the calendar and a time from the dropdown, and select Schedule. Where the request waits depends on where you scheduled it: • New session: In the Drafts section of the sessions list. • Existing chat: In that chat's Scheduled area, with its send time. If the agent is still busy at the scheduled time, the request waits its turn instead of interrupting. Alternatively, you can ask the agent to schedule a request for you by using plain language in the chat prompt, for example: "Check the build in 10 minutes." The agent schedules a one-time, text-only request in the current chat and confirms when it will be sent. The request appears in the chat's Scheduled area, like one you scheduled from the menu. The local agent host must be running at the scheduled time. Scheduling doesn't wake a sleeping computer. A missed request is processed once the host is available again. To manage your scheduled requests (edit, send immediately, reschedule, or cancel), use the options available when you hover over them in the chat or session list. To find sessions with pending requests, look for the clock indicator in the session list, or select Scheduled Only in the sessions filter menu. Learn more about scheduling requests in the Send Later documentation. Note: Scheduled requests work only for sessions on This Computer and require automations to be enabled (chat.automations.enabled). Save and resume drafts (Experimental) Setting: sessions.drafts.enabled Previously, the new-session input held a single unsent request at a time. With drafts, you can keep several unsent requests side by side, each with its own workspace, agent, and configuration, and come back to any of them later. When you leave a new session that has content, VS Code saves it to the Drafts section of the sessions list. Nothing is sent, and no agent session starts. To jump right back, select Open Draft in the notification. Each draft keeps everything you set up: text, attachments, inline references, workspace, agent, model, and other configuration. Drafts survive reloads and restarts. From the Drafts list, you can preview, open, or delete a draft. When you send a draft, it's removed only after the request is accepted, so a failed send doesn't lose your work. Turning off the setting hides the Drafts section but keeps your saved drafts. Share remote environments as GitHub Environments Share a remote as a GitHub Environment to pick up its agent sessions from another device or supported Copilot app, using your GitHub account. To share a connected SSH host, WSL distribution, or Dev Tunnel, open the Remote Environments editor in the Agents window and select Share as GitHub Environment (GitHub icon) on the remote's row. A shared remote stays in its group and shows a GitHub icon after its name. Select the action again to stop sharing. Learn more about remote agent sessions. Keep chat sessions across Dev Container rebuilds (Experimental) Settings: dev.containers.stateVolume.enabled, chat.agentHost.devContainer.stateVolume.enabled Rebuilding a Dev Container used to remove the Copilot chat sessions stored inside it. When you enable these settings, VS Code stores the user and agent state of a new Dev Container on a Docker volume, preserving your chat sessions across rebuilds. Important: A container gets the volume only when it's created with the setting enabled, so rebuild once to start keeping your sessions. Inbox mode improvements (Experimental) Setting: sessions.list.inboxEnabled Inbox mode groups your Agents window sessions by what needs your attention. You can switch to Inbox mode at any time with Grouping > Inbox Mode in the sessions list. The sessions.list.inboxEnabled setting makes it the default grouping. This release builds on your feedback to make Inbox mode more useful and manageable: • Acknowledge sessions you've handled If a session doesn't need your attention but isn't finished, you can mark it as acknowledged (eye icon). Acknowledging a session moves it out of the Inbox and into the Acknowledged section. The session isn't marked as read or done, archived, or closed. When there is new activity in the session, it returns to the Inbox. You can acknowledge several selected sessions at once. • Focus on one workspace or environment Use the workspace and environment pickers at the top of the sessions list to see only the sessions you care about right now. The filter applies to every section, including pinned and archived sessions, and is remembered across reloads. Agent experience Decision model-based model routers (Experimental) Setting: chat.copilot.modelRouter.enabled With a model router, you describe which model you want for which kind of work. A decision model, gpt-6-luna-decisions, then matches your request to one of your routes, and VS Code runs the chat on that route's model. A router is a YAML file in ~/.agents/model-routers/ that appears in the model picker in Copilot harness sessions. Model routers are at an early stage, and your feedback will help shape them. Tell us what works and what doesn't by filing an issue. version: 1 description: Opus to build, GPT-6 Luna for quick questions. routes: - model: opus when: Building or changing code over many steps, such as a feature, a bug fix, or a refactor. - model: gpt-6-luna when: Quick answers and small chores, such as where something is or what a setting does. To try model routers, add "chat.copilot.modelRouter.enabled": true to your user settings.json file. To author a router, type /model-router in a Copilot harness chat and describe how you want your requests routed. Then select the router in the model picker. Model comparison improvements (Preview) Model comparison lets you run the same prompt across models in the Agents window, so you can review, judge, and combine their results. This release makes comparisons easier to find and understand: • Comparisons stay with their chat: When you ask an agent to run a comparison, it appears beneath that chat in the sessions list. The agent's response includes an Open Comparison action to go straight to the results. • See how a comparison was set up: Hover over a comparison in the sessions list to see its original settings: repository, isolation, base branch, each attempt's model and effort level, judge, and synthesizer. You no longer need to open each attempt to check. HTML previews and native visuals in agent responses Settings: chat.htmlPreview.enabled, chat.nativeComponents.enabled (Agents window only) Some agent responses are easier to review as a visual or a chart than as text, such as a comparison of approaches, a mockup, or build times before and after a change. In the Agents window, agents can show these inline in the response in two ways. Each has its own setting, which is off by default. • HTML previews: For free-form layouts, such as reports, diagrams, and mockups. Previews display HTML, CSS, tables, inline SVG, and expandable sections. Scripts, forms, external links, and external resources aren't supported. Enable chat.htmlPreview.enabled and use the built-in /html-preview skill in your request, for example /html-preview compare the two caching approaches. • Native visuals (Experimental): For data, such as key numbers and comparisons. Agents can show metrics, badges, tables, bar charts, and expandable details that VS Code renders itself, so they match your theme, including high-contrast themes. Enable chat.nativeComponents.enabled and use the built-in /vscode-ui skill in your request, for example /vscode-ui compare the full and incremental build times. Both appear as part of the response, without a title bar or permanent buttons. Right-click a preview or visual and select Show Source to see its markup. For an HTML preview, you can also select Open Preview for a larger view or Save HTML to export a self-contained HTML file. Automations Automations allow you to define tasks that run automatically based on specific triggers and conditions. You can create, manage, and monitor automations from the Automations view in the Agents window. This release adds guided setup, end dates, and filters for automation runs: • Agent-guided automation creation Creating an automation with an agent is now a more guided experience. The agent helps you define what a successful result looks like, decide when the automation runs, and choose where it runs. To start, ask an agent to create an automation. You can also select Create with Agent in the Automations view to continue in chat. If you prefer configuring everything yourself, open the dropdown next to Create with Agent and select Create Manually. • Set an end date for automations Automations can stop automatically after a specified duration. Set an end date when creating an automation with an agent, or choose Days, Weeks, or Months under Advanced Settings in the manual configuration form. Select Never to remove an existing end date. • Filter automation runs in session lists Automation runs are hidden from session lists by default. Use the Automations filter to include or exclude them in the Agents window and the editor Chat sessions list. More context for assisted permissions Setting: chat.permissions.assisted.instructions With assisted permissions, an LLM reviewer assesses each tool call in Copilot harness sessions and approves low-risk calls for you. Previously, the reviewer relied only on its default guidance, so it couldn't account for what you consider safe or risky in your own work. Use chat.permissions.assisted.instructions to give the LLM reviewer your own instructions, for example: Always ask before installing packages or pushing to a remote. Running tests and read-only Git commands doesn't need my approval. Your instructions take precedence over the reviewer's default guidance. Changes to the setting apply to sessions that are already open. They can't override permission rules, organization policy, or the sandbox, and they aren't sent to the agent. The reviewer also takes into account who asked for the work: • Automations and other agents: Requests that an automation starts or that another agent sends are no longer treated as if you wrote them. In these sessions, tool calls might ask for approval where they previously didn't. • Your answers: Your answers to an agent's questions and plan reviews count, including when you decline. An approval can cover later work that your answer describes, and a refusal can block an action that was approved before. Arrange the Details panel around the editor (Experimental) Settings: sessions.experimental.detailsPosition, sessions.experimental.floatingDetails (Agents window only) In the Agents window, you can position Files, Changes, and other Details views around the editor to make better use of the available space. Open View > Appearance > Details Position and choose Left, Right, Above Editor, Below Editor, or Floating. Right is the default. Floating Details overlays the editor instead of reserving space. Hover over or focus the widget to preview its contents, then select the pin control to keep it open. You can also drag and resize it. View extension info The Extensions section of Customizations shows the same detailed information about each installed extension, including its version, publisher, and available commands, as you can from the Extensions view in the editor window. Chat Attach screenshots of other apps (Experimental) Setting: chat.appWindowScreenshots.enabled Give the agent a view of the app you're building, even when it runs in another application. Select Add Context > Screenshot App Window and choose a window, such as a browser or simulator. You can also press Ctrl+Shift+Alt+S while another app is in the foreground to capture its window and attach it to the chat. From VS Code, the shortcut captures the app window you just left. You can mark up the image before sending. Capture and mark up images in chat Select Mark Up on any image attachment in the chat input to crop it, draw arrows or shapes, or add text before sending. This works with screenshots, pasted images, and images attached from files, so you can point out a layout problem or highlight the part you want changed. Inline chat attachment pills (Experimental) Setting: chat.inlineAttachments.enabled Inline chat attachments show files, images, and other context as pills at the position where you added them in your prompt, so references stay next to the instructions they belong to. Recent updates make the pills more useful in the chat input and in sent requests: • Preview and open GitHub references: Hover over or focus a GitHub issue or pull request pill to see its title, status, and description. Select the pill to open the issue or pull request. In sent requests, where selecting a pill previously did nothing, this also works when inline attachments are off. • Rearrange pills by dragging: Drag a pill to a new position in the same chat input, rather than removing the context and attaching it again. • Clearer sent requests: Sent requests show attached images as thumbnails above the text, in addition to the inline pills. Pills and slash commands line up with the surrounding text. Image and GitHub pills are restored after you reload the window, instead of appearing as plain links. Inline attachments are enabled by default in Insiders and off by default in Stable. Browser integration Let agents use your browser with browser use (Preview) Setting: chat.agentHost.browserUse.enabled Browser Use lets agents interact directly with your default browser (Google Chrome or Microsoft Edge). This complements VS Code's integrated browser, for example by allowing agents to reuse existing authenticated sessions and interact with web pages outside of VS Code. Browser Use requires the GitHub Copilot browser extension, a Copilot harness session that runs on your own machine, and Node.js 22 or later on your PATH. To get started with Browser Use: • Enable the chat.agentHost.browserUse.enabled setting and restart VS Code. • Open a local Copilot session and enter /plugin enable browser-use to enable the browser-use plugin. • Ask Copilot to perform a browser task, for example: Open my app at localhost:3000, check the navigation, and capture a screenshot. • Approve site access when prompted; complete sign-in and sensitive steps yourself. • Run /browser-use:doctor and follow its guidance to check your setup in case of any issues. Preview remote HTML files in the integrated browser (Preview) Setting: workbench.browser.enableRemoteProxy You can now open HTML files from a remote workspace, such as SSH, WSL, or a Dev Container, in the integrated browser, just like local HTML files. In the Explorer, right-click an HTML file and select Open in Integrated Browser. The page keeps its file:// address, and the file and the resources it references, such as scripts, styles, images, and fonts, load from the remote workspace. Remote files only load from folders you trust. This also works in the Agents window for sessions on a remote agent host, so you and the agent can preview a page the agent wrote without copying it to your machine. Enable workbench.browser.enableRemoteProxy to try it out, and file any issues you encounter in the VS Code repository. Open non-localhost links in the integrated browser Setting: workbench.externalUriOpeners Localhost links could already open in the integrated browser with workbench.browser.openLocalhostLinks. The integrated browser is now listed as an opener in the workbench.externalUriOpeners setting, so you can choose it for other links instead of using the default browser. For example, to open links to your company's sites in the integrated browser: "workbench.externalUriOpeners": { "*.contoso.com": "workbench.integratedBrowser" } Use * as the pattern to open every link there instead. Turn off dimming in the integrated browser Setting: workbench.browser.dimOnOverlay When something overlaps the integrated browser, such as a tab hover or a tooltip, the page pauses and dims. As hovers come and go, the page repeatedly darkens and returns to normal, which might appear as flicker and be uncomfortable for users who are sensitive to it. You can now disable workbench.browser.dimOnOverlay to keep the page undimmed while it's paused. Notifications still dim the page. Sandboxing Retry with updated permissions inside the sandbox If a terminal command fails because it can't access a file or folder, you can grant access at the session, workspace, or user level. With sandbox bypass enabled, Copilot can use that permission to retry the command inside the sandbox instead of asking to run it outside. Use the approval dropdown to choose where the permission applies: • Allow for This Session (default): Applies to all chats in this session, even after you resume it. • Allow for This Workspace (when available): Applies to sessions with the same workspace folders on the same Agent Host. The host saves the permission without changing your workspace settings. • Allow for This User: Saves the permission in your User settings so it applies across sessions and workspaces. The command retries inside the sandbox. None of these options grants permission to run outside it. Accessibility Clearer focus and session attention In high-contrast themes, Agents window controls now use a dashed outline for pointer hover and a solid outline for keyboard focus and open or expanded states. This makes it easier to follow your focus when navigating. Sessions that need input are also easier to spot: light themes use a clearer amber indicator, and high-contrast themes show a marker at the left edge of the session row. You can customize the color with agentSessionNeedsInput.foreground in workbench.colorCustomizations. Editor Experience Customize panel corners and spacing Setting: workbench.sizeCustomizations Customize panel corners and spacing in the editor window and in Agents windows with the Modern UI enabled. Set corner radii in whole pixels from 0 to 8 and spacing from 0 to 16. For example, you can use square panel corners, add space between panels, and give agent chat panels their own corners: { "workbench.sizeCustomizations": { "panels.cornerRadius": 0, "panels.spacing": 12, "agentsWindow.chatPanels.cornerRadius": 4 } } Compact layouts remain gapless, and the setting doesn't change controls, individual tabs, or native window corners. Connected panel tabs (Experimental) With the Modern UI enabled, the connected tab style now extends from editor tabs to horizontal panel and side bar tabs. Selected views visually connect to their content, including when the Activity Bar is at the top or bottom. Choose connected (the default) or pill with workbench.experimental.modernUIEditorTabStyle. The default vertical Activity Bar is unchanged. Edit Markdown tables cell by cell Editing a Markdown table in the source means keeping pipes and separator rows intact by hand. In the Markdown editor, tables stay rendered while you edit them, and you edit one cell at a time. Collapsible details sections in the Markdown editor Long documents often hide optional content in <details> sections. The Markdown editor now renders <details> and <summary> as collapsible sections, like GitHub does. Sections with the open attribute start expanded, and other sections start collapsed. Enterprise Permit Claude and Codex alongside managed settings Previously, any Copilot enterprise-managed setting disabled the Claude and Codex harnesses, because they don't enforce those settings. An organization couldn't govern Copilot and still offer Claude or Codex to its developers. Administrators can now permit one or both harnesses by listing them in vscode.allowedHarnesses: { "permissions": { "disableBypassPermissionsMode": "disable" }, "vscode": { "allowedHarnesses": [ "claude", "codex" ] } } • The list permits the harnesses it names and blocks the others, so an empty list blocks both. Without the setting, managed settings disable both harnesses, as before. • Valid entries are claude and codex, in lowercase. Other entries are ignored. • Permitting a harness only lifts this restriction. Other controls still apply, such as vscode.temporaryAllowLocalHarness: false. • Set it in file-based or MDM-managed settings. Server-managed settings don't support it yet. Note: Permitting a harness doesn't make it enforce your managed settings. Claude and Codex sessions run without Copilot's managed permission, sandbox, MCP, and plugin controls. Regular expressions in managed shell permission rules Previously, managed shell permission rules matched only exact text or * wildcards, so a single rule couldn't cover alternatives or word boundaries. In Copilot harness sessions, Shell(...), Bash(...), and PowerShell(...) rules in enterprise-managed settings accept a JavaScript regular expression written as /pattern/flags in permissions.deny, permissions.ask, and permissions.allow. For example, require approval for commands that start with git push or git pull: { "permissions": { "ask": [ "Shell(/^git\\s+(push|pull)\\b/)" ] } } 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: • When GitHub Actions workflows are waiting for a maintainer's approval, such as for a pull request from a first-time contributor, the checks section of the pull request overview has an Approve workflows to run button. • Comments and other timeline items in the pull request overview use the full width once they're below the sidebar, and the overview switches to a single column below 1000px wide instead of 768px. • In the Agents window, the pull request overview can be split into Timeline, Checks/Merge, and Metadata tabs with the experimental setting "githubPullRequests.experimental.agentsOverviewTabs". The Timeline tab shows the number of unresolved conversations, and the Checks/Merge tab shows whether the pull request is ready to merge. Review the changelog for the 0.180.0 release of the extension to learn about everything in the release. Deprecated features and settings New deprecations in this release • VS Code desktop on macOS Ventura and macOS Sonoma is deprecated. For details, see the VS Code FAQ. • VS Code desktop on 32-bit ARM Linux is deprecated. For details, see the VS Code FAQ. • The experimental AI usage statistics in the Status Bar (editor.aiStats.enabled) are removed because of low usage. Upcoming deprecations • The Local harness is deprecated and will be removed in February 2027. Thank you Issue tracking Contributions to our issue tracking: • @gjsjohnmurray (John Murray) • @RedCMD (RedCMD) • @IllusionMH (Andrii Dieiev) • @albertosantini (Alberto Santini) Pull requests Contributions to vscode: • @AAAkater: agentHost: fix incorrect model attribution in Codex subagent responses PR #340470 • @Aryan9891 (Aryan Sachin): fix(terminal): support multiple action view items for create terminal dropdown (#_346848) PR #346854 • @Boulea7 (Langning Zhang): Fix PWA manifest start URL for server base paths PR #330360 • @DivyaRaval1909 (Divya Raval): Hide action list item icon and submenu indicator from screen readers PR #339952 • @Iyanuoluwa007 (Oke Iyanuoluwa Enoch): Report problems of pending lines when a task problem collector is done PR #346122 • @mcumming (Michael Cummings (MSFT)): Never send Entra sign-in tokens to the marketplace PR #343689 • @NeoMetric: agentHost: stream BYOK model output as it is produced PR #341851 • @rudy-07 (Rudransh Shekhar): terminal-suggest: fix root directory check in npm and yarn package.json lookup PR #347265 • @sameerihs (Sameer) ◦ Reset notebook controller language restrictions PR #347068 ◦ Clean up obsolete webview resource caches PR #346867 ◦ Use pending URLs when restoring browser tabs PR #346996 ◦ Invalidate cached TS responses after document reopen PR #347028 ◦ Keep the latest debugger source refresh PR #347124 ◦ Track forwarded tunnel connections by socket PR #347033 ◦ Keep task problem markers scoped to each terminal PR #346994 ◦ Isolate copied notebook output items PR #347117 ◦ Cancel stale format-on-type requests PR #347115 ◦ Keep configuration retries on their original file PR #347074 ◦ Keep in-memory working copy backups distinct PR #347066 ◦ Serialize rapid virtual document refreshes PR #346986 ◦ Clear buffered results before a new Quick Search PR #347031 • @ShakilUrRehman21 (SHAKIL UR REHMAN): map: preserve custom toKey and re-key on ResourceMap copy PR #347344 • @shoutoutuoadi325 (Zhiqi Zhang): Fix UTF-16 column counts in TextLength PR #345715 • @SimonSiefke (Simon Siefke) ◦ fix: memory leak in word highlighter PR #346673 ◦ fix: memory leak in task providers PR #338231 ◦ fix: memory leak in untitled editor resolution PR #346674 ◦ perf: avoid rescanning test children in Test Explorer PR #347176 ◦ perf: batch Test Explorer test run updates PR #346656 ◦ fix: memory leak in test results terminal PR #347183 ◦ feature: reduce idle CPU usage by up to 75% PR #338767 ◦ fix: race condition in notebook kernel picker PR #341483 ◦ fix: memory leak in SCM repository context keys PR #346683 ◦ fix: memory leak in emitter warning names PR #347966 ◦ perf: reduce memory usage by 44 kB PR #342392 ◦ fix: memory leak in markersView PR #348007 • @trivikr (Trivikram Kamat): Add --hidden-window to run extension tests without showing a window PR #344174 • @wasim-builds (MOHAMMED WASIM KHAN): fix: prevent DisposableStore leak per tree node in ExtHostTreeView (#_346620) PR #346727 • @wozhenbang2004 (Kayokoi): Fix authentication provider cleanup when an extension host stops PR #345127 • @wynnsimon (wynn): fix: Fix findWithArgs ignoring empty search strings (#_151311) PR #334803 • @YOSHII-Hiroto (吉井 啓人(YOSHII, Hiroto)): Fix element picker with mobile emulation PR #332183 Contributions to vscode-pull-request-github: • @hungud (Uong Dong Hung): fix: handle null review comment commit in parseGraphQLComment (fixes #9159) PR #9168 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
  • Nov 11, 2026
    • Date parsed from source:
      Nov 11, 2026
    • First seen by Releasebot:
      Nov 11, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.146

    Visual Studio Code adds a more flexible agent workspace with inbox mode, standalone chat windows, and extensions in the Agents window. The release also improves model comparisons, canvas workflows, Copilot harness security, and virtual repository support, while beginning the Local harness deprecation.

    Release highlights

    Save your brainpower for the work that needs it. Inbox mode keeps the right sessions on your radar while agents take on model comparisons. Shape your agent workspace around the task with chat windows and extensions.

    • Inbox mode (Experimental): Focus on sessions that need your attention across all your projects, and snooze others for later.
    • Model comparison (Preview): Compare results with Copilot Fusion in the mix, or let an agent run comparisons for you.
    • Chat windows (Preview): Give chats their own windows and rearrange chats, editors, and terminals to fit the task.
    • Extensions in the Agents window (Experimental): Find and install extensions for a richer agent experience.
    • Local harness deprecation: Move to the Copilot harness before the Local harness is removed in February 2027.

    Happy coding!

    Agents

    Copilot harness and deprecation of the Local harness

    The Copilot harness is our latest agent harness and has been the default for new sessions since VS Code 1.143. It's built on the Copilot SDK, a shared foundation that helps align behavior, capabilities, and improvements across Copilot products. Copilot harness sessions run through the Agent Host, so you can keep them running in the background and access them from both the VS Code editor window and the Agents window. For organizations, the Copilot harness also enforces managed sandbox and permission policies that the Local harness doesn't.

    Thank you to everyone who has shared feedback on using the Copilot harness as your default. Your feedback has shaped the harness experience, and it will continue to guide us through this next step. As of this release, the Local harness is deprecated and will be removed in three months (February 2027):

    • Next three months: You can still use the Local harness while you move your workflows, but it's functionally frozen. New features and improvements will focus on the Copilot harness and are not guaranteed to be supported by the Local harness.
    • After three months: The Local harness will no longer be available. The vscode.temporaryDefaultToLocalHarness enterprise-managed setting, introduced in VS Code 1.142 to keep the Local harness as the default, will also be removed.

    Because the Copilot harness is already the default for new sessions, you might not need to take any new actions. To confirm you're using the Copilot harness, look for Copilot in the harness picker when you start a new session.

    If you still use the Local harness, plan to move completely to the Copilot harness before February 2027. The Local-to-Copilot harness transition guide covers customization compatibility, continuing existing Local conversations, and organization rollout and verification. If you run into any problems, let us know by filing an issue.

    Inbox mode for sessions (Experimental)

    Setting: sessions.list.inboxEnabled

    Keep track of your agents without checking each workspace. Inbox mode gives you one view of what needs your attention, what's still running, and what's ready to merge.

    Enable the sessions.list.inboxEnabled setting (off by default), and then select Grouping > Inbox Mode in the Agents window's sessions list.

    Sessions that need your attention appear at the top, above the Working, Ready to merge, On hold, and Done groups. If a session can wait, use Dismiss from Inbox, Put on Hold, or Snooze to set it aside. Select Undo if you change your mind.

    Dismissing a session doesn't archive it. To archive it, select Mark Session as Done.

    Session list inline actions (Experimental)

    Setting: sessions.list.inlineActions

    Fix failing checks and address review comments directly from the Agents window's sessions list. Enable this setting (off by default) to show inline actions for fixing checks, addressing comments, or both.

    Each action sends a request to that row's session or nested session in the background without opening it. The setting does not enable Agent Merge or change action permissions.

    Chat windows (Preview)

    Setting: sessions.chatWindows.enabled

    When several chats run at once, keeping them all in one Agents window means switching between them and losing sight of the one you are waiting on. With chat windows, you can open a chat in a window of its own, and arrange that window so that the chat, its editors, and its terminals fit the task.

    To try this preview feature in Stable, enable sessions.chatWindows.enabled. It is enabled by default in VS Code Insiders, and off by default in Stable.

    Learn more about chat windows in our documentation.

    To open a chat in a new window, right-click the session or chat in the sessions list and select Open in > New Window. You can also drag a chat out of the Agents window to create a new window. You can move it back with the Move to Main Window command.

    A chat window can hold several chats from one or more sessions: pick another session in its title bar, drag a chat in from another window, or select New Session (Ctrl+N) at the left of the title bar to start a new session in that window. Chat windows reopen with their chats and editors after you restart VS Code.

    The content within a chat window is organized into parts, which you can arrange freely to fit your workflow.

    • Move parts: Drag a part by the grabber on the top edge of its card to another side of the window, or beside another part. You can also use Move Part Left, Move Part Right, Move Part Up, and Move Part Down.
    • Move tabs between parts: Drag a tab to another part, or drop it on a part's edge to split that part. Use Move Editor to Part or Move Editor into New Part Left/Right/Above/Below to do the same from the Command Palette. Drag an editor tab onto the chat input to attach it to the chat as context.
    • Place the terminal: Dragging the terminal under the editor or under the chat sets Terminal Position to Under Editor or Under Chat. Dropping it on the bottom edge of the window sets Full Width. You can also change the position from the ... menu of the terminal.
    • Switch the layout: Use Configure Layout in the title bar to show the chat, the editor, or both, side by side or stacked. In the stacked layout, Agents: Toggle Chat Conversation collapses the chat to only its input, so the editor takes the rest of the window.

    Use Developer: Reset Chat Window Layout to return a window to how it first opened.

    Let us know what you think by filing an issue.

    Install and manage extensions in the Agents window (Experimental)

    The Extensions section of Agent Customizations lets you choose which installed extensions run in the Agents window without changing their enablement in editor windows. Previously, adding an extension meant switching to an editor window to install it. In this release, you can find, install, and uninstall extensions without leaving the Agents window:

    • Install from the Marketplace: Searching also queries the Marketplace and lists matching extensions that you don't have yet, with their publisher, install count, and rating. Installing an extension adds it to VS Code and enables it in the Agents window. To install a different version, such as a pre-release, use the dropdown next to Install.
    • Know what won't work before installing: Extensions that contribute views, debuggers, status bar items, or walkthroughs without declaring support for the Agents window show a warning that lists the unsupported features. Extensions that can't be installed, for example because your organization doesn't allow them, show the reason.
    • Open with a keyboard shortcut: Press Ctrl+Shift+X or run Extensions: Manage Extensions to open the section. If you changed the shortcut for the Extensions view in editor windows, your shortcut also works in the Agents window.

    Model comparison improvements (Preview)

    Setting: sessions.chat.compareAgents.tools.enabled

    Compare Models in the Agents window lets you run the same prompt across models, evaluate their results with a judge, and combine their strengths with a synthesizer. This release makes comparisons easier to configure, organize, and automate:

    • Judge and synthesize chat-only responses: Add a judge and synthesizer without selecting a workspace. Synthesis starts when you select Synthesize and creates a new chat without changing the original attempts.
    • Compare Copilot Fusion: Select Fusion and its supported effort tiers for an attempt, the judge, or the synthesizer.
    • Let an agent run evaluations (Experimental): Enable sessions.chat.compareAgents.tools.enabled to let agents discover models, launch comparisons, and read results and conversation references to summarize findings across scenarios. The tools are off by default and require Compare Models to be enabled. Disabling them still leaves manual comparisons available.

    Canvases improvements (Preview)

    Setting: chat.canvases.enabled

    Canvases are shared, interactive surfaces where you and Copilot work together on plans, dashboards, and other artifacts. This release adds permission prompts and improves canvas discovery and continuity:

    • Permissions for canvas extensions: In Copilot harness sessions, canvas extensions ask for your approval before initializing privileged capabilities, such as hooks.
    • Find and reopen canvases: Canvas menus distinguish Running canvases from Available canvases you can create new instances for. In the Agents window, actions to create or install canvases appear under Discover More.
    • Resume without another prompt: When you return to an inactive Copilot harness session, its canvases restore without sending another message.
    • Smoother reconnection: While a canvas provider restarts, the last canvas image stays visible with a reconnecting indicator.
    • Keep canvases with their chats: In separate chat windows, canvas tabs close when their chat leaves the window and can reopen alongside it. Canvases also restore after a window reload without taking focus.

    Configure computer sharing (Experimental)

    Setting: sessions.chat.experimental.remoteEnvironmentsThisComputer

    The Remote Environments editor in the Agents window is a central place for managing remote connections. In this release, you can now manage how this computer is shared with other clients. Regardless of whether sharing is enabled, local sessions continue to run directly on this computer.

    Share this computer through GitHub Environments or Dev Tunnels, or turn sharing off. You can also change the computer name that other clients see.

    Open the editor with Manage Remote Environments from the Environment picker in chat, the Command Palette, or the title bar's Remote Connections menu (antenna icon), which also offers the same sharing options.

    Learn more about making a host available for remote access.

    Agent Host support for virtual repositories

    VS Code supports virtual workspaces, allowing you to do things like viewing a GitHub repository without having to clone it.

    The Copilot harness previously did not work in virtual repositories. In this release, we added support for virtual repositories, so you can use the same Copilot features and workflows as you do in local folders.

    Chat

    Continue a Copilot CLI session in VS Code (Experimental)

    When you're working with the GitHub Copilot CLI in a terminal outside VS Code, you can now move the session into VS Code and keep going.

    Enter /code in the CLI, or /code-insiders for VS Code Insiders. The CLI exits, and VS Code opens the same session in the Chat view of the window for the session's folder, starting VS Code if it isn't running. The session keeps its conversation history, its model and reasoning effort, and its mode and permissions.

    The /code command is experimental in Copilot CLI. It requires Copilot CLI 1.0.107 or later, with experimental features turned on (/settings experimental on). Permissions that apply only to the CLI process, such as --allow-tool or approvals you granted for the session, don't carry over, and the CLI lists them before handing off. If another Copilot CLI process still has the session open, VS Code asks before opening it. To return to the CLI, run the copilot --resume command that the CLI shows when it hands off.

    Configurable shortcut for the background send action

    Setting: chat.sendInBackgroundTip.enabled

    Start a new session without opening it by pressing Ctrl+Enter in the Agents window composer. You can rebind or remove the shortcut for Chat: Send in Background in Keyboard Shortcuts.

    An optional tip shows your configured shortcut and links to Keyboard Shortcuts. Enable it with chat.sendInBackgroundTip.enabled (Experimental, off by default).

    MCP

    Skills over MCP (Preview)

    Setting: chat.agentHost.mcpSkills.enabled

    This release of VS Code adds support for SEP-2640 Skills over MCP, allowing MCP servers to automatically provide skills to the model.

    The first time you connect to an MCP server that provides skills, you are asked to allow them into your model context. Afterwards, the model can interact with these skills and you can see them on the Skills tab of the Agent Customizations editor.

    Trust and security

    Improved permission prompts

    The Copilot harness previously suggested overly broad tool-level allowances for operations like web fetches, terminal commands, and file reads. For example, the default action for fetching a URL was "Allow in this Session", which would let the model access any URL during that session.

    Now, permission prompts are more granular, by default adding allowances for specific domains, commands, and directories.

    Mask environment variables in the sandbox

    Setting: chat.agent.sandbox.credentials.envVars

    To protect sensitive information, you can configure which environment variables are masked in sandboxed sessions and hidden from agent tools. Sandboxed tools receive placeholders, and the real values are supplied only to approved HTTPS destinations.

    In this example, sandboxing replaces the value of the API_TOKEN environment variable with a placeholder. The real value is restored only in outgoing HTTPS requests to hosts listed in injectHosts, here api.example.com. Requests to other hosts retain the placeholder and don't receive the actual value.

    {
      "chat.agent.sandbox.credentials.envVars": {
        "API_TOKEN": {
          "injectHosts": [
            "api.example.com"
          ]
        }
      }
    }
    

    Enter variable names, not secret values, in settings. On Windows, environment variable masking requires local-network access. On macOS and Windows, trust the sandbox CA certificate for tools that require OS certificate trust.

    See sandbox network access and certificate trust for more information.

    Sandbox status in the chat input

    See whether terminal sandboxing is enabled without opening the Permissions menu. In both the editor and the Agents window, the empty chat input shows (sandbox enabled) when Sandboxing for terminal is on. The placeholder stays in sync as you switch chats or change the setting.

    Accessibility

    Visible keyboard focus on Welcome

    The Welcome page shows a visible outline when the page itself has keyboard focus, so you can track your position while navigating. The page remains focusable for screen reader users.

    Editor Experience

    Mermaid 12 support

    VS Code now uses Mermaid 12 when rendering Mermaid diagrams in chat, Markdown previews, and notebooks. You can use new diagram types, including use-case diagrams, and benefit from updated automatic layout behavior.

    Copy the address of local HTML files in the Integrated Browser

    When you preview a local HTML file in the Integrated Browser, you can select and copy its file:// address to paste it into an external browser or a terminal.

    Enterprise

    Copilot sessions behind enterprise proxies

    Copilot sessions follow VS Code's proxy configuration, including proxy auto-configuration (PAC) and Kerberos authentication, when running locally, in WSL, or in a local Dev Container. Your organization's routing rules can select different proxies or a direct connection for each destination, rather than forcing requests through a single proxy.

    Organization help links for policy restrictions

    Organizations can direct blocked developers to their own help page by setting communication.support.url in enterprise-managed settings. We recommend pointing this URL to a page where employees can find their organization's Copilot usage policies and support guidance. A valid absolute HTTP or HTTPS URL adds Contact Admin links to supported policy restrictions, such as disabled Agents or organization-disabled models.

    For example, in your organization's managed settings:

    {
      "communication": {
        "support": {
          "url": "https://ai.example.com/your-companys-ai-landing-support-page"
        }
      }
    }
    

    Enterprise controls for canvas extensions

    In Copilot harness sessions, strictPluginOnlyCustomization already restricted standalone skills, agents, hooks, and MCP servers. It now also blocks standalone canvas extensions from user, project, and session directories, so administrators can require that any canvas extensions used come from eligible plugins.

    In enterprise-managed settings, use true to block all supported standalone categories while allowing eligible plugin content:

    {
      "strictPluginOnlyCustomization": true
    }
    

    To restrict only selected categories, replace true with a list containing any of "skills", "agents", "hooks", "mcp", and "extensions".

    Note: VS Code's boolean-only ChatStrictPluginOnlyCustomization policy does not control canvas extensions. The Copilot SDK manages them, so use the Copilot managed setting above.

    See the enterprise-managed settings reference for policy details.

    Deprecated features and settings

    New deprecations in this release

    • The Local harness is deprecated and will be removed in February 2027.

    Upcoming deprecations

    None

    Notable fixes

    Fixed overcounting in agent edit metrics

    Agent edit metrics reported through GitHub Copilot usage metrics no longer count unchanged text between edits as newly added or deleted code.

    Original source
  • All of your release notes in one feed

    Join Releasebot and get updates from Microsoft and hundreds of other software products.

    Create account
  • Nov 4, 2026
    • Date parsed from source:
      Nov 4, 2026
    • First seen by Releasebot:
      Nov 5, 2026
    • Modified by Releasebot:
      Nov 7, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.145

    Visual Studio Code adds remote agent app previews and canvases, flexible cron scheduling for automations, and new controls for chat verbosity. The update also improves file exclusions and enterprise settings, with smoother long chats and a playful Blobby game.

    Release highlights

    This week, your remote agent sessions feel a bit more local. Preview apps and use canvases right in VS Code, fine-tune automation schedules with cron, and turn down the noise in chat. And when you need a break, Blobby is ready to play.

    • Remote agents: Preview apps and use interactive canvases from remote agent sessions without leaving the Agents window.
    • Automations: Run recurring agent tasks on custom schedules beyond the built-in presets with cron.
    • Agent verbosity: Keep chats concise or see the full details of the agent's reasoning and tool calls, your choice.
    • File exclusions: Exclude folders while keeping the files you need visible and searchable.
    • Fun: Take a short break with a platform-jumping game starring Blobby, the VS Code pet.

    Already installed? Use Check for Updates in VS Code. For upcoming features, use the Insiders build.

    Remote agents

    Browse over remote agent host connections (Preview)

    Setting: workbench.browser.enableRemoteProxy

    When an agent session runs on a remote agent host, the integrated browser in the Agents window now loads pages through that host, as it already does in remote workspaces. When the agent starts a dev server on the remote machine, you can open it right in the Agents window to preview the app, validate the agent's changes, and give it feedback, as you would in a local session.

    Enable workbench.browser.enableRemoteProxy to try it out, and file any issues you encounter in the VS Code repository.

    Remote canvases (Preview)

    Settings: workbench.browser.enableRemoteProxy, chat.canvases.enabled

    Thanks to the remote agent host connections support, you can now also use canvases that are hosted on a remote agent host.

    Enable chat.canvases.enabled and workbench.browser.enableRemoteProxy to try it out, and file any issues you encounter in the VS Code repository.

    Agents

    Mix and match agent harnesses in one session (Preview)

    Setting: chat.agentHost.multipleChatProviders.enabled

    Nested sessions let you keep related conversations together within a single main chat session. Previously, every nested session inherited its parent session's harness. If you wanted a second opinion from another agent, you had to start a separate session and lose that grouping.

    In this release, nested sessions can use different harnesses than their parent session. For example, ask Claude to review the plan that a Copilot chat wrote, or give Codex the same task, side by side in the same session. When you create a new nested session, use the harness picker to switch to a different harness.

    Each chat has its own model, agent, and permission levels, based on its harness. Changing them in one chat doesn't affect the others. When you move a chat, it keeps its history and continues with its selected harness. When you fork a nested session, it continues with the same configuration.

    A chat that uses a different harness than its session names its harness when you hover over its chat tab or its row in the sessions list.

    Enable chat.agentHost.multipleChatProviders.enabled to get started. Let us know what you think by filing an issue.

    Cron schedules and custom agents for local automations

    Instead of manually running agent tasks one by one, you can use automations to schedule and run them automatically, either on demand or on a set schedule.

    This release gives you more flexibility for local automations and keeps the Automations view focused on active work:

    • Use cron schedules: Select Cron to enter a five-field cron expression when the other schedule presets aren't precise enough. The dialog validates the expression and describes the resulting schedule. Cron schedules are not available for cloud automations.
    • Use workspace custom agents: Choose a custom agent from the selected workspace when you create or edit a local automation.
    • Focus on active automations: Disabled automations appear in a collapsed Disabled automations section, so they don't obscure run history and active automations.

    Learn more about creating and managing agent automations.

    Pin canvases to sidebar (Experimental)

    Setting: chat.canvases.enabled

    To make it easier to access frequently used canvases, you can now pin a canvas to appear in the left sidebar. To pin a canvas, open it and select the Add to Sidebar button above the canvas. Pinned canvases remain accessible in the sidebar even when you navigate away from them.

    Copilot harness

    The Copilot harness continues to be the default for new sessions in VS Code. It's our latest harness, built on the Copilot SDK, a shared foundation that helps align behavior, capabilities, and improvements across Copilot products.

    When you start a new session, Copilot in the harness picker indicates that the session uses the Copilot harness. In VS Code, you can keep Copilot harness sessions running in the background and access them from both the VS Code editor window and the Agents window. These sessions run through the Agent Host.

    To help you adopt the Copilot harness with your existing workflows, we've added a Local-to-Copilot harness transition guide. It covers customization compatibility, session continuity, and organization rollout and verification.

    Thank you for the feedback that continues to shape these improvements. Please continue filing issues about your experience, especially if a workflow or integration prevents your organization from moving off the Local harness.

    Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post.

    Working set improvements (Experimental)

    Setting: chat.editor.workingSet.enabled

    Last release, we introduced the working set for Copilot harness sessions, letting you review pending agent edits. You can keep or undo changes, as you could do with the Local harness.

    We are further improving the working set experience in Copilot harness sessions:

    • Files in WSL, Dev Containers, and SSH workspaces open from the working set on the correct host.
    • When several tool calls edit the same file in parallel, the working set tracks those edits and the editor's inline review controls remain available after editing finishes.

    The working set functionality remains enabled by default in the editor window. Learn more about reviewing agent edits with the working set, including which edits it tracks.

    Improved guidance when required sandboxing is unavailable

    Agent sandboxing limits what terminal commands can access, like the file system and network resources. Your organization can require it with managed settings that disallow bypassing the sandbox.

    If your organization requires sandboxing but your machine can't run it, the warning banner explains why terminal commands are blocked and how to resolve the problem. It shows the specific cause, such as a missing dependency, and links to troubleshooting steps.

    If your account and organization support cloud sessions (Experimental), consider running agent tools in the cloud instead of on your machine.

    Chat

    Choose agent verbosity (Experimental)

    Setting: chat.persistentProgressVerbosity

    Keep long chats readable, or follow the agent's reasoning and tool calls in detail when you need to understand its actions. Open the Chat view's More Actions menu and select View Mode:

    • Conversation: Focus on the conversation. Reasoning and tool calls are grouped into collapsed sections between blocks of response text. Expand a section to inspect its details.
    • Verbose: Follow each step with tool calls expanded, without an internal scrolling limit on tool groups.
    • Compact (default): Preview tool calls while they run, then collapse completed groups to expandable summary rows.

    You can switch modes without starting a new chat. The modes change how the conversation is displayed, not its context or the work the agent performs.

    With persistent progress enabled, the active progress indicator stays above the chat input while you scroll back through a response. If you prefer an animated input border instead, enable chat.progressBorder.enabled.

    Chat performance improvements

    Reopen and browse long Copilot harness chats more smoothly. VS Code reuses existing reasoning titles and renders terminal output as you reveal it. Terminal output in restored tool calls is rendered when you expand or reveal it, rather than all at once.

    This release also reduces repeated progress updates and layout measurements when restoring and navigating long conversations.

    Inline chat attachments (Experimental)

    Setting: chat.inlineAttachments.enabled

    Keep file references and other context next to the instructions they belong to. Enable this setting to insert attachment pills at the cursor in your prompt, rather than in a separate row above the input.

    Move across, select, or delete an attachment pill as a single character. Previous messages keep the pills inline, so references stay with the surrounding instructions.

    Inline attachments are on by default in Insiders and off by default in Stable.

    Attach files from anywhere on your computer

    Previously, to give chat a file outside your workspace, such as a screenshot or mockup on your desktop, you had to drag it in from your file manager or ask the agent to find it. Select Add Context (+) > Files to choose one or more files with the standard file dialog, even in a new chat without a workspace. In cloud sessions, the chooser lists only images.

    When sandboxing is enabled in Copilot harness sessions, the agent can read the files and folders you attach, even when they're outside the workspace. Each attached path is readable for the rest of the session, but the agent can't write to it, and the access isn't saved to your settings. With Manual permissions, the agent no longer asks before reading an attached file. If your organization's managed settings define their own list of readable paths, attachments aren't added to it.

    MCP

    Support for tools provided by MCP apps

    MCP apps are interactive interfaces provided by MCP servers. They can now register tools that the language model can call in its next request.

    For example, the ShaderToy server lets the model iterate on shaders in real time.

    Managed MCP allowlist precedence

    For MCP servers started by VS Code, the enterprise-managed allowedMcpServers list takes precedence over registry-only access, so your organization can approve servers without publishing them to its registry. See the Enterprise section on managed MCP allowlists for configuration details and restrictions.

    Editor Experience

    Show specific files in excluded folders

    Settings: files.exclude, search.exclude

    You can filter which files and folders are shown in the Explorer, Search, and Quick Open by using the files.exclude and search.exclude settings.

    To keep part of an excluded folder visible, prefix a pattern with ! in files.exclude. Matching files and folders show in the Explorer, Search, and Quick Open, even when another pattern or .gitignore excludes them. Exceptions in search.exclude apply only to Search and Quick Open.

    "files.exclude": {
      "node_modules": true,
      "!node_modules/@types": true
    }
    

    Exceptions never hide files. Patterns such as !**/node_modules/@types match at any depth but can make searches slower.

    Smart subgraph titles in Mermaid diagrams

    Edges in Mermaid diagrams no longer cover subgraph titles. A title moves to the side when an edge would cross it. With the default vscode Mermaid theme, subgraphs are outlined instead of filled, so nested subgraphs stand out.

    Enterprise

    Organization-required plugins can't be uninstalled

    When your organization requires an agent plugin, for example with the enabledPlugins managed setting, the Customizations views previously offered Uninstall for it. That action always failed and changed to Retry Uninstall, which also failed. The same happened for the prompts, skills, agents, hooks, and MCP servers that the plugin contributes.

    {
      "enabledPlugins": {
        "my-plugin@my-marketplace": true
      }
    }
    

    The Uninstall action for these plugins and their contributions is now disabled and a message is shown on hover and keyboard focus. This applies to Browse, the plugin details, the plugin editor, and the plugin and MCP server menus.

    Managed MCP allowlists take precedence over registry-only access

    Previously, when an organization limited MCP to servers from its registry and also defined an allowlist in managed settings, VS Code still required each server to be in the registry. Servers that the allowlist approved but that weren't published to the registry couldn't run.

    The enterprise-managed allowedMcpServers list is now authoritative. A server that matches the list can run even if it isn't in the registry, and a registry server that doesn't match is blocked. For example, the following enterprise-managed settings allow one remote server and one local server:

    {
      "allowedMcpServers": [
        {
          "serverUrl": "https://mcp.example.com/mcp"
        },
        {
          "serverCommand": ["node", "approved-server.js"] }
      ]
    }
    
    • An empty list ([]) blocks all servers. If the list is absent, the registry restriction applies as before.
    • User and workspace allowlists can't add servers to the enterprise list.
    • deniedMcpServers and turning off MCP still take precedence over the allowlist.
    • Prefer serverUrl and serverCommand rules. A serverName rule matches a label that the server's author chooses.

    Note: This change applies to MCP servers that VS Code starts, not to servers managed by the Agent Host.

    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:

    • The pull request overview timeline shows more events, including label, milestone, and title changes, review requests and dismissals, draft and ready-for-review changes, force pushes, branch restores, auto-merge changes, and merge queue updates.
    • Pull request description templates support issue variables such as ${issueTitle}, ${issueNumber}, and ${issueNumberLabel}, filled in from the issue associated with the branch by "Start Working on Issue".
    • When you stack pull requests, you're prompted to disable auto-merge on any pull request in the stack that has it enabled.

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

    Extension Authoring

    Timeline API finalized

    Extensions published to the Marketplace can add their own history to the Timeline view, next to Git commits and Local History. Register providers with workspace.registerTimelineProvider for files and folders, or workspace.registerWorkspaceTimelineProvider for the whole workspace. Set TimelineItem.resourceUri to the resource's content as of that entry so users can compare it with other entries by using Compare Selected.

    Learn more about the Timeline API in the Timeline API documentation.

    Fun!

    Blobby jump game (Experimental)

    Take a short break with Blobby, the VS Code pet. Enter /vscode-pet in chat to show Blobby. On the new-session screen in the Agents window, choose Play Jump Game from Blobby's context menu. Hold the spacebar to charge a jump and use the arrow keys to aim for the next platform. The game remembers your high score on this device.

    Deprecated features and settings

    New deprecations in this release

    Install Extension tool removed from the Local harness

    The Install Extension (#installExtension) agent tool is no longer available in Local agent sessions. When you create a new workspace from chat, the agent no longer installs extensions. Instead, it adds the extensions the project needs to .vscode/extensions.json, so you can review and install them from the Extensions view. When you run a Python cell in a Jupyter notebook without the Jupyter extension, the kernel picker prompts you to install it.

    If your custom agents or prompt files reference #installExtension, remove that reference.

    Run VS Code Command tool removed from the Local harness

    The Run VS Code Command (#runCommand) agent tool is no longer available in Local agent sessions. Built-in workflows that relied on it now work without it. For example, when chat diagnoses network issues, it asks you to run Developer: Chat Diagnostics and share the report.

    If your custom agents or prompt files reference #runCommand, remove that reference.

    Workspace creation tool and slash command removed from the Local harness

    The Create New Workspace (#newWorkspace, previously #new) agent tool and the /new slash command are no longer available in Local agent sessions. The Generate New Workspace link on the Welcome page is also no longer available. The dedicated project-setup skills are removed.

    To create a project, open an empty folder and describe the project you want in an agent session. The agent uses its standard tools to create files, run scaffolding commands, and configure tasks.

    Remove references to #newWorkspace, #new, /new, project-setup-info-local, and project-setup-info-context7 from your custom agents and prompt files. The github.copilot.chat.newWorkspaceCreation.enabled, github.copilot.chat.newWorkspace.useContext7, and github.copilot.chat.useProjectTemplates settings are also removed. Notebook creation is unchanged.

    Upcoming deprecations

    None

    Notable fixes

    • When an organization turned off the Claude or Codex agent, users who had picked that agent before got a read-only chat with no input from New Chat (+), New Chat Editor, and new windows. New chats now fall back to the default harness, and an unsent prompt carries over. Your previous choice applies again if the policy is lifted. #345207
    • When an organization set MCP access to registry only in its GitHub Copilot policies, a failed policy refresh, for example from a network error or rate limiting, removed the restriction until the next successful refresh. VS Code now keeps the last known registry policy, and clears it only when GitHub reports that no registry applies. #344895

    Thank you

    Issue tracking

    Contributions to our issue tracking:

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

    Pull requests

    Contributions to vscode:

    • @bompus (Aaron Queen): Refresh markdown preview html before a hidden panel is rebuilt PR #334681
    • @cipheraxat (Akshat Anand): web: release code -w -g file:line once the file's editor closes PR #344740
    • @denizguney (Deniz Güney Yıldırım): test: add mock reset configuration and test coverage support PR #338159
    • @hardikkaurani (Hardik K): fix(arrays): throw TypeError for negative indices in quickSelect PR #342816
    • @hirossan4049 (hirose): editorFind: fix swapped findMatch foreground colors (#_228782) PR #270395
    • @kinqsradio (Anh Dang)
      • Fix requireLocalPort for range, regex, and host-and-port rules PR #344185
      • Preserve inherited port protocol for exact-port attributes PR #344764
    • @nathan-vincent-dev (nathan vincent): Fix typos "curent" and "filterd" PR #345134
    • @Nikhil-4404 (Nikhil Kumar): Fix SSE stream-wide byte order mark handling PR #344094
    • @pl4nty (Tom Plant): win32: fix installer's context menu COM surrogate kill command PR #344505
    • @rfeltis (Ralph Feltis): Log telemetry when the closed-chat promo pip is armed PR #337997
    • @RReverser (Ingvar Stepanyan): Fix copilot code reference output channel race PR #342272
    • @SimonSiefke (Simon Siefke)
      • fix: task system readiness races PR #342418
      • fix: memory leak in terminal auto replies PR #336022
    • @spencrr (Spencer Schoenberg): agentHost: add setting to turn off Copilot's Co-authored-by trailer PR #339437
    • @VaggelisGian (Vaggelis Giannopoulos): Progress: store scoped while state with start time and delay swapped PR #332735
    • @vscodebot-pr (VS Code PR Bot): fix: guard ListView dynamic-height probe against shrunk model (fixes #333550) PR #333563
    • @wozhenbang2004 (Kayokoi): testing: respect keybindings before type-to-filter PR #344892
    • @wycats (Yehuda Katz): Recognize userPromptTransformed plugin hooks in Copilot sessions PR #345068

    Contributions to vscode-pull-request-github:

    • @kinqsradio (Anh Dang): Fix orphan stack worktree cleanup through macOS path aliases PR #9100
    • @tamird (Tamir Duberstein): Batch Git config reads for branch operations PR #8978

    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
  • Oct 28, 2026
    • Date parsed from source:
      Oct 28, 2026
    • First seen by Releasebot:
      Nov 2, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.144

    Visual Studio Code releases a major update focused on agent workflows, with sessions that continue across environments, Copilot Fusion model orchestration, image generation, safer tool approvals, and expanded customization. It also brings computer use, richer session management, and a refreshed editor experience.

    Release recap

    The road to GitHub Universe (join us virtually!) is paved with lots of pull requests! So, let's take a step back and look at what we've shipped recently.

    • Remember when agent sessions would stop as soon as you closed your client? We built the Agent Host, a separate process that keeps your agents running, on your local machine or remotely.
    • With language servers in mind, we designed the Agent Host Protocol (AHP) to allow any client to interact with agent sessions. All of sudden, session continuity across VS Code, Copilot CLI, GitHub Copilot App, and github.com lets you pick up right where you left off.
    • The Agents window lets you manage your agents across workspaces and environments from a single interface, whether you kick off things yourself or use automations to handle repetitive tasks.
    • By default, agents are now powered by the Copilot harness, the same harness used in Copilot Code Review, the Copilot CLI, the Copilot App, and Copilot Cloud sessions. Write agent customizations once and use them consistently across all these experiences.
    • If you prefer Anthropic's Claude Code harness or the one from OpenAI Codex, just use those instead with your Copilot subscription and enjoy the familiar VS Code developer experience.
    • As we continue to offer new models from different providers, how do you decide which one is best suited for your task? With model comparisons (aka Agent Bake-Off), run the same prompt against multiple models and harnesses to see which performs best. Prefer a hands-off approach? Use Copilot Fusion to choose the best model and orchestrate multiple models to work together for your task.
    • We've had vision capabilities for a while, but you kept asking for more. The wait is over, and now you can also prompt the agent to generate images directly in chat.
    • Chat is not always the best interface for every task. With canvas support, you can create rich, interactive UI to interact with your agents and visualize their outputs.
    • Coding with agents can be more than just writing code. Let agents interact with the browser to validate their results, or let them drive apps on your computer for automation and task execution.
    • If you need it, build it! So, we created a beautiful new Markdown editor. Instead of editing the raw Markdown, you can edit the rendered Markdown directly. And, of course, you can still edit the source if you prefer.
    • And if you didn't notice, we also refreshed the overall look and feel of VS Code, so it looks fresh and beautiful in light and dark themes.

    Read all about this, and more, in our VS Code Wrapped blog post.

    Release highlights

    This release helps you keep agent work moving across environments, find the right models for each task, and stay in control of changes and tool calls.

    • Session continuity: Manage remotes in one place and keep sessions and automations running even when your computer is off.
    • Copilot Fusion and model comparisons: Let Copilot choose and orchestrate models, or compare models side by side.
    • Image generation (Preview): Create and edit images directly in chat.
    • Computer use (Experimental): Let agents use desktop apps on your computer.
    • Working set (Experimental): Keep or undo agent file edits in the editor.
    • Assisted permissions: Reduce interruptions with automatic approval for tool calls that pass a risk check.
    • Customization marketplace and Copilot connectors (Preview): Discover skills and plugins for your workflow, and bring context from Slack, Notion, and other services into your agent sessions.

    Already installed? Use Check for Updates in VS Code. For upcoming features, use the Insiders build.

    Session continuity

    Run and continue Copilot tasks in the cloud

    Cloud sessions let you run Copilot tasks from VS Code without keeping your development machine online. Your repository and tools run in a managed environment on GitHub's infrastructure.

    From the Chat view in the editor window or the Agents window, you can:

    • Select Cloud and choose a GitHub repository to start a task.
    • Send follow-up instructions, respond to approval requests, and review the agent's changes.
    • Reopen an existing cloud session from the sessions list to continue the same conversation.

    Your cloud sessions are also accessible from other Copilot clients. For example, you can check progress on GitHub.com or in the GitHub Mobile app, then return to VS Code to continue working.

    Cloud sessions use a separate workspace. Local uncommitted changes aren't automatically copied. The new cloud experience requires a paid Copilot plan and is subject to organization policies.

    Manage remote environments

    VS Code lets you run agents and perform development tasks across different (remote) environments. To make it easier to manage these environments, we're introducing the Remote Environments dialog, which brings your GitHub Environments, Dev Tunnels, WSL distributions, and SSH hosts together in one place.

    Select Manage Remote Environments at the bottom of the Environment picker to see the status of each remote, connect or disconnect, and choose which remotes should be visible in the pickers.

    Learn more about remote agent sessions.

    Cloud Automations (Preview)

    Setting: chat.automations.cloud.enabled

    Create and manage Copilot cloud automations directly in the Agents window. Enabled by default, they run on GitHub infrastructure on a schedule or in response to repository events, even when your computer is off.

    To create a cloud automation, you can ask an agent to set one up for you, or use the Create Automation button in the Automations view in the Agents window.

    With cloud automations, you can:

    • Set up automations that run in response to issue or pull request events: Act automatically when activity happens in your repository. For example, automatically triaging issues as they get assigned to you.
    • Build shared workflows in the cloud with your team: Create automations that are visible to everyone with access to the repository and act as Copilot.
    • Control exactly when your agent runs and what it can do: Limit allowed tools and add filters for precise control over your automations. For example, trigger an automation when you are assigned an issue with a specific label.

    To learn more, see Create and manage agent automations in the Visual Studio Code docs.

    Agent Host Protocol v1.0

    We've published the first version of the Agent Host Protocol, the protocol that VS Code uses to communicate with its agents locally and on remote machines, including for cloud automations. It's an open, extensible protocol designed to be an easy way to build custom UI's for your agents, or build agent platforms that plug into any UI that speaks it.

    You can add a websocket-based agent host to your VS Code instance via the command Agents: Add Remote Agent Host... in the Agents window, and run code agent endpoints to get the endpoints for your editor's running agent host. We publish libraries in six languages and have found agents are good at making clients and hosts using them.

    You can read more about the protocol and find additional resources on the Agent Host Protocol website.

    Models

    Route and orchestrate models with GitHub Copilot Fusion

    Instead of picking a model for each task, select Copilot Fusion in the model picker and let Copilot intelligently route requests and orchestrate models for you. Copilot Fusion brings together Project HydraFusion's multi-model orchestration and Copilot auto model selection's task-aware model selection to balance performance and cost efficiency.

    For each request, Copilot Fusion chooses the models, reasoning effort, and execution pattern for your task. For example, one model completes a simple task, while for harder tasks one model drafts a solution and other models review or critique it. Hover over the effort level below a response to see which models were used.

    Choose an effort level to balance quality and cost: Standard for everyday coding work, High for more demanding tasks, and Max for the most complex tasks.

    You're billed for each model that Copilot Fusion uses at its standard rate. Through November 30, 2026, paid Copilot plans receive a 30% discount when using Copilot Fusion.

    GitHub Copilot Fusion is now generally available, with Copilot Fusion High and Max offered on Copilot Pro+, Max, Business, and Enterprise plans. To learn more, see our documentation on GitHub Copilot Fusion.

    Compare models and harnesses by default and in more projects

    Setting: sessions.chat.compareAgents.enabled

    Model comparisons run the same prompt across models for side-by-side review. They are enabled by default for eligible new sessions in the Agents window, unless overridden by user settings or experiments.

    In this release, we expanded model comparison to more scenarios:

    • Explore ideas without a project: Run independent attempts from a folderless Chat, without a Git repository, judge, or synthesizer.
    • Start with a local or empty repository: A Git remote and an initial commit are no longer required. For repositories without commits, each isolated attempt starts from a snapshot of non-ignored working files without changing your source branch or index.

    To open comparison setup from the keyboard, press Ctrl+Alt+M from an eligible chat input or model picker.

    Within setup, navigation buttons name their destination, such as Configure Judge, Configure Attempts, and Configure Synthesis, instead of using generic next and previous labels.

    Note: Model comparisons are not supported in Dev Containers.

    Image generation in Copilot (Preview)

    Setting: chat.copilot.imageGeneration.model, chat.copilot.imageGeneration.watermark.

    Agents can generate images from your prompts with GPT Image 2.5 Flare. Ask the agent to create an image for your website, a chat background, a new icon, or a website wireframe. You can also add an existing image as chat context and ask the agent to modify it or generate variations.

    The default image model is GPT Image 2.5 Flare. To disable image generation, set chat.copilot.imageGeneration.model to off. Image generation requires access to the selected model and uses AI credits in addition to those used by the conversation model.

    Additionally, set chat.copilot.imageGeneration.watermark to true to add a perceptible Made with AI watermark to your image.

    Agent integration

    Let agents use desktop apps with computer use

    Setting: chat.agentHost.computerUse.enabled

    Some tasks happen in desktop apps rather than in your code or the terminal. With Computer Use, the agent can see and control apps on your computer. Computer Use works in Copilot harness sessions that run on your own macOS or Windows machine.

    When a task needs Computer Use, the agent asks you to allow turning it on, or you can run /computer on. Computer Use stays on for Copilot until you run /computer off.

    Learn more about Computer Use in the documentation.

    Canvases (Preview)

    Setting: chat.canvases.enabled

    Previously introduced in VS Code 1.142, Canvases are shared, interactive surfaces where you and the agent can inspect and update the same artifact. This release makes canvases easier to find, manage, and open.

    Manage canvases in the Agent Customizations editor

    The Agent Customizations editor's Canvases section lists the canvases available to the active Copilot session and groups their contributing canvas extensions by source. To see it, open a Copilot session with at least one message in it, and open the Agent Customizations editor from there.

    Under the Browse section, select Canvases to find plugins whose metadata indicates that they provide canvases. Some canvas-capable plugins might not have that metadata and would appear under Plugins instead. Learn how to manage canvas extensions.

    Open canvases from the Add Context menu

    In chats in the editor or Agents window, select Add Context (+) > Canvas... to open or refocus an available canvas.

    This adds another entry point alongside New Chat (+) > Canvas in the editor window and Add Tab (+) > Canvas in the Agents window.

    Agents

    Assisted permissions are generally available

    Agents can make many tool calls to accomplish a task. Approving every tool call ensures that each action is explicitly authorized, but it can become cumbersome for frequent or low-risk calls. Giving the agent full autonomy might be risky and result in unintended actions or security issues.

    With assisted permissions (now generally available for Copilot sessions), the agent performs an LLM-based risk assessment for each tool call and automatically approves low-risk calls. When a call is deemed higher risk or if the risk cannot be determined, the tool call still requires explicit user approval. This approach gives you a balance between convenience and security.

    Select Assisted permissions in the permissions picker to have an LLM assess tool-call risk. Calls it approves run without prompting, while other calls still require your confirmation. Assisted permissions require Folder isolation and might be restricted by your organization. Read the GitHub announcement of assisted permissions general availability.

    Session composer controls (Experimental)

    Starting a new agent session is something you do often, so we've grouped the key settings at the top and added shortcuts for quick access.

    Choose the environment first

    With session continuity, where you run an agent session and where you access it from is completely up to you. So, when you create a new session in the Agents window, selecting the environment where the session runs is likely the first thing you do. Use the environment picker to choose from This Computer, Cloud, an eligible remote host, or a supported Dev Container.

    The other configuration options will change based on the selected environment. For example, creating a session locally will let you specify the branch and worktree code isolation options.

    To hide the Environment picker, disable sessions.chat.experimental.environmentPicker.

    Chat without a project

    Setting: sessions.chat.experimental.workspaceOptOut

    Sometimes you just want to start an agent conversation that is not associated with a specific workspace or folder (workspace-less chat). Rather than scrolling through the workspace picker, you can dismiss the current selection by hovering over (or on keyboard focus) the picker and selecting X.

    Enable sessions.chat.experimental.workspaceOptOut to enable dismissing the selected workspace.

    If you dismiss the selected workspace for an ongoing session, your prompt and attachments are preserved. The action is available only for harnesses and environments that support workspace-less chat.

    Reduce clutter

    To reduce visual clutter, you can reduce each of the key configuration options to only show their icon. Right-click the UI control and select Collapse to Icon. Each picker retains its tooltip and accessible name, and your choices persist across reloads and Settings Sync.

    Use the keyboard

    From the focused new-session chat input, use Ctrl+K Ctrl+E, Ctrl+K Ctrl+B, Ctrl+K Ctrl+T, or Ctrl+K Ctrl+Y to reach available controls. Collapsed session options expand as needed. The Sync shortcut only moves focus. Press Enter to synchronize.

    Copilot harness as the default

    The Copilot harness continues to be the default for new sessions in VS Code. It's our latest harness, built on the Copilot SDK, a shared foundation that helps align behavior, capabilities, and improvements across Copilot products.

    When you start a new session, Copilot in the harness picker indicates that the session uses the Copilot harness.

    In VS Code, you can keep Copilot harness sessions running in the background and access them from both the VS Code editor window and the Agents window. These sessions run through the Agent Host.

    Review Copilot file edits with the working set (Experimental)

    Setting: chat.editor.workingSet.enabled

    The Copilot harness records edits made through agent tools in a working set, so you can review and decide which changes to keep or undo, just like in the Local harness. Use the inline Keep and Undo controls in the editor for individual changes, or manage files and all pending changes from the working set above the chat input.

    Keep and undo are enabled by default in the editor window and remain experimental. Set chat.editor.workingSet.enabled to false to show the Changes pill instead. Changes made through terminal commands do not appear in the working set. In the Agents window, use the Changes view to discard files.

    Thank you so much to everyone who has shared valuable feedback. This release includes more improvements shaped directly by your feedback. Please continue filing issues to let us know how the Copilot harness is working for you. Your feedback is a huge help and directly shapes the harness experience.

    Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post.

    Copilot Memory in the Copilot harness

    Copilot harness sessions can now use Copilot Memory, the same cloud memory service that other Copilot surfaces like Copilot CLI, Copilot cloud agent, and Copilot code review also use.

    Agents recall relevant repository facts and your preferences when a session starts, and store new learnings as you work, so you don't have to repeat the same context in every new conversation.

    Memories are stored as repository facts, which are shared with others who have access to the repository, or as user preferences, which apply across your repositories. Ask the agent to remember a convention or preference, and state the scope when it matters:

    Across all my repositories, remember that I prefer concise commit message subjects.

    Copilot Memory is enabled by default and respects your Copilot Memory settings on GitHub and your organization's policies. You can review and delete your memories on GitHub at any time.

    Learn more about using memory with agents.

    Manage worktree storage (Experimental)

    Setting: chat.agentSessions.sessionStorageCleanupSuggestion.enabled

    Last release, we introduced worktree storage cleanup for agent sessions to help you reclaim disk space used by worktrees. This release adds more ways to find the worktrees you want to remove:

    • See all past worktrees: The Any time option is selected by default, to let you review recent worktrees as well as older ones.
    • Find worktrees by workspace: Each row shows its workspace, and a workspace filter narrows the results. Changing the workspace filter clears the selection.

    When cleanup suggestions are enabled and a local worktree's disk has less than 5 GB available, the Agents window provides a suggestion below the sessions list to run worktree cleanup, regardless of worktree age or count. The suggestion opens cleanup with Any time selected.

    Enable extensions in agents window

    Extensions can run and be enabled or disabled directly from the Agents window. This requires extensions.experimental.agentsWindowManagement to be set to true.

    Agent customizations

    Connect services with Copilot connectors (Preview)

    Bring the Slack discussion behind a change, project context from Notion, or API documentation from Microsoft Learn into your agent sessions. Copilot connectors are GitHub-managed MCP servers that connect your agent to these services without local server setup or MCP configuration.

    Open Browse, choose Copilot Connectors in the source menu, and select Connect on a service. Authorize access in your browser. Connect once and reuse the connection across supported Copilot clients signed in with the same account.

    Connectors are enabled by default on all Copilot plans and work only with the Copilot harness. For Business and Enterprise, an administrator must enable Editor preview features. Your organization's MCP restrictions apply, and some services require administrator approval.

    Discover marketplace customizations (Preview)

    Add skills, tools, and entire workflows to your agent without building them from scratch. Browse, the new home page for Customizations, brings together GitHub Feed and plugins from marketplaces configured by you or your enterprise.

    Explore Editor's picks, Plan, build, and ship, and Connect your work, or search and filter by source or type. Open Browse or run Chat: Open Customizations to start.

    Link to Browse from a README or team guide, optionally with a search. For example, Browse filtered to MCP servers.

    GitHub Feed requires a supported harness and isn't available in Local sessions. For Copilot Business and Enterprise, an administrator must enable Editor preview features.

    Richer editing for GitHub Copilot custom agents

    When you customize agents for the GitHub Copilot harness, completions, hovers, and validation help you choose available models, tools, and skills and catch configuration errors before you run the agent.

    • Models: The model attribute offers Copilot model IDs as a single value or an ordered list of preferences.
    • Tools: The tools attribute offers Copilot tool aliases, such as read, edit, and execute, alongside qualified client and extension tools.
    • Skills: The skills attribute offers available skills, with descriptions and source information in completions and hovers.
    • Configuration validation: Copilot-specific attributes and nested structures, including hooks and agent-scoped MCP servers, have completions, hovers, and validation. Unknown models, tools, and skills are only flagged after discovery has finished, so valid values aren't marked as errors while inventories are still loading.
    • Body features: In GitHub Copilot agent files, placeholders such as and are recognized and show hovers. Unknown placeholders and Local-only #tool: and #file: references are flagged.

    Harness-aware defaults for custom agent editing

    When your .agent.md file has no target attribute, the editor now uses the active customization harness to provide matching completions, hovers, and diagnostics. Switching harnesses refreshes this guidance without reopening the file. An explicit target: vscode or target: github-copilot continues to override the default.

    Share links to plugins and customizations

    You can share deep links in a README or team guide to help others add an agent plugin marketplace, install a specific plugin, or open a page in the customization dialog.

    Action | Example link
    Add a marketplace | vscode://chat-plugin/add-marketplace?ref=owner/repo
    Add a marketplace and install a named plugin | vscode://chat-plugin/install?source=owner/repo&plugin=plugin-name
    Open the Plugins page with a search filter | vscode://chat-customizations/open?page=plugins&search=github

    Replace owner/repo with the marketplace's GitHub repository and plugin-name with the plugin's name in that marketplace. VS Code asks for confirmation before adding a marketplace or installing a plugin. These actions use a Copilot harness session; if none is available, VS Code asks before creating one. Only proceed if you trust the source, because plugins can run code on your machine.

    Use these links for Install in VS Code buttons in your plugin's README, as shown in the Session timeline plugin's getting started section.

    Customization links also support pages such as agents, skills, instructions, hooks, mcp-servers, tools, and migrations. Omit search to open the page without a filter. Use vscode-insiders:// instead of vscode:// to open VS Code Insiders.

    Manage Copilot customizations with slash commands

    You can manage plugins, MCP servers, and skills without leaving the Chat view in a Copilot harness session. Type /plugin, /mcp, or /skills followed by a space to see the available subcommands.

    • Plugins: List, install, update, enable, disable, or uninstall agent plugins. Use /plugin marketplace to manage marketplaces, or /plugin install to choose a plugin to install.
    • MCP servers: Use /mcp show, /mcp enable, or /mcp disable with a server name to inspect or manage your MCP servers.
    • Skills: Use /skills info with a skill name to inspect an available agent skill.

    Completions suggest supported subcommands and relevant plugin, marketplace, server, or skill names. Available commands depend on the Copilot runtime, and results appear directly in chat.

    Session management

    Move chats between sessions (Preview)

    Setting: chat.agentHost.moveChats.enabled

    The Agents window lets you organize related conversations into sessions. Rearrange those conversations as your work evolves without starting over or losing their history.

    • Drag a nested chat into another session, or drop it between that session's nested chats to choose its position.
    • Right-click a nested chat and select Promote to Session to give it its own session. You can also drag it onto empty space in the sessions list.
    • Drag a single-chat session onto another session to nest it there.
    • Reorder nested chats by dragging them, or use Move Up and Move Down from their context menu. With focus in the sessions list, use Shift+Alt+Up and Shift+Alt+Down.

    Moves preserve the chat's working folder, including an existing worktree or a temporary folder for a chat without a workspace. A shared worktree remains available while another session still uses it. Moves between sessions require the same agent and provider, and a destination that supports multiple chats. Subagent conversations move with their parent chat rather than independently.

    The sessions list shows move progress and provides Undo after a move. Enable the setting to try this feature in Stable; it is on by default in Insiders.

    Learn more about organizing sessions in the Agents window.

    Choose a workspace for nested sessions

    Previously, nested sessions inherited the workspace of their parent session. Now, you can choose a separate workspace for each nested session. This lets you work across repositories while keeping related conversations together in one session. For example, a frontend chat and a backend chat can work in different folders without splitting the task across separate sessions.

    Select New Nested Session in the Agents window to open a composer with a folder picker that defaults to the parent session's folder. Choose a recent folder, browse to another folder, or select No Workspace for a chat with its own temporary folder.

    For a Git repository, choose New Worktree and a branch to isolate the nested chat's file changes. The nested chat uses its parent session's agent and host. Agents that do not support multiple working directories offer only the parent session's folder.

    Nested sessions in quick chats

    Follow up on a quick chat without mixing separate questions into one conversation or losing track of related discussions. For example, explore two approaches in separate nested sessions under the same quick chat, without opening a project folder.

    Quick chats in the Agents window support nested sessions: select + on a quick chat or use New Nested Session from its context menu.

    Each nested session starts with No Workspace selected and gets its own temporary folder, separate from the parent quick chat. The quick chat stays in the Chats section, keeping its related conversations together.

    Custom icons and colors for session groups

    Make workspace groups, environment groups (including remote hosts), and custom groups easier to recognize with custom icons and theme-aware colors. In the Agents window, open a group's context menu and select Change Icon... or Change Color... . Your choices persist across reloads and host reconnections, and Reset to default restores the icon or color independently.

    Chat

    Voice conversations with session context (Experimental)

    Voice Mode (agents.voice.enabled) lets you discuss tasks aloud while the coding agent works. Use an OpenAI live model with your own API key (agents.voice.useBYOKVoiceModel) to ask questions such as 'Where were we?' or 'Which session needs input?' without starting a coding request.

    The enabled-by-default agents.voice.sessionAwareness shares a bounded briefing of tracked sessions and recent active-chat context with OpenAI BYOK Voice Mode. It includes session titles, response summaries, pending prompt details, the selected model, and attachment names, but not attachment contents.

    Voice Mode's animation uses a single color for a more conversational feel: you can jump in and speak at any time.

    GPT Live conversations also handle follow-ups and ongoing work more predictably:

    • Ask questions while the agent works and hear the answers, with other updates queued and read aloud afterward.
    • Single-question forms read the full question, and multi-question forms collect one numbered answer at a time.
    • New spoken coding instructions during ongoing work are sent as steering rather than queued until the task finishes. Steering applies at the next opportunity supported by the provider and does not guarantee immediate interruption. Voice-only exchanges during ongoing work are not retained for later requests.

    Localized voice approvals and clearer connection status (Experimental)

    Approve or reject GPT Live tool requests in your selected voice language (agents.voice.language), with support for 25 languages and English as a fallback. Answer questions with displayed choice labels, numbers, or free text where allowed. Ambiguous approvals still require an explicit answer or chat controls.

    The voice language setting does not translate agent-provided questions or choices. Commands such as 'skip' and 'other' remain English-only.

    Editor Experience

    Issue Reporter

    Settings: issueReporter.wizard.enabled, issueReporter.wizard.openLocation, issueReporter.additionalRepositories

    Issues with clear steps, screenshots, and logs are faster for us to reproduce and fix. The new issue reporter, which you turn on with issueReporter.wizard.enabled, makes it easier for you to create high quality issues. You can capture screenshots and screen recordings without leaving VS Code, from the capture bar or with kb(workbench.action.issueReporter.captureScreenshot) and kb(workbench.action.issueReporter.toggleRecording).

    This release makes these changes to the new issue reporter:

    • The form fits on a single page instead of three steps.
    • Attach other files that help us debug your issue, such as log files or zip archives. You can also paste or drop images and videos into the form.
    • The reporter opens in its own window. To open it in an editor tab instead, set issueReporter.wizard.openLocation to editor.
    • To file issues in other GitHub repositories, for example your team's own tracker, add them to issueReporter.additionalRepositories in owner/repo format. Then pick the repository in the form.

    Terminal

    Dialogs from terminal commands open in front of VS Code on Windows

    Setting: terminal.integrated.windowsReparentConsoleWindow

    On Windows, some command-line tools open dialogs that could appear behind VS Code when run from the terminal. For example, the Azure PowerShell Connect-AzAccount sign-in picker opened behind the VS Code window, so the command looked stuck until you moved or minimized VS Code.

    VS Code now makes the window that shows each local terminal the owner of that terminal's hidden console window, as Windows Terminal does. Dialogs that tools attach to their console window now open in front of the VS Code window the terminal is in.

    This requires terminal.integrated.windowsUseConptyDll, which is enabled by default. To turn off this behavior, set terminal.integrated.windowsReparentConsoleWindow to false.

    Enterprise

    Clearer permission restrictions

    Assisted and Allow All remain visible but disabled when restricted by your organization, with an explanation instead of disappearing.

    Example Copilot managed settings:
    {
    "permissions": {
    "disableAssistedPermissionsMode": true,
    "disableBypassPermissionsMode": "disable"
    }
    }

    Organization-managed session defaults

    New chats in the Editor and Agents windows respect your organization's default model, Copilot Fusion tier, and permission level, taking precedence over remembered selections. You can change these defaults within a session where policy allows; unavailable permission modes fall back to Manual.

    Example Copilot managed settings, for organizations with Fusion Max available:
    {
    "model": "fusion",
    "fusionTier": "max",
    "permissions": {
    "defaultMode": "assisted"
    }
    }

    Managed settings loading progress

    When organization settings load slowly, progress appears inline in the waiting chat instead of stacking notification toasts. Background loading no longer interrupts you.

    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:

    • The "Update stack" action now uses the GitHub API to update a stacked pull request when possible, so you no longer need to have a pull request from the stack checked out.
    • The pull request overview shows a banner offering to create a stack when the pull request's branches line up with other open pull requests that aren't stacked yet.

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

    Extension Authoring

    Publish extensions with OIDC and Trusted Publishing

    You can now publish extensions to the Visual Studio Marketplace from GitHub Actions without storing a Personal Access Token (PAT) as a repository secret. The vsce publish --oidc command requests a short-lived OpenID Connect (OIDC) token from GitHub Actions and exchanges it for a temporary Marketplace credential that is valid for up to 15 minutes. If the token exchange fails, vsce doesn't fall back to a PAT.

    To get started, create a Trusted Publishing policy for your repository and workflow in the Visual Studio Marketplace publisher management page, grant the publishing job the id-token: write permission, and run vsce publish --oidc in your workflow. Use a version of @vscode/vsce that supports OIDC, such as 4.0.2 or later.

    Trusted Publishing is currently supported for GitHub Actions only. For Azure Pipelines, continue to use Microsoft Entra ID with a service connection. As global PATs in Azure DevOps are retired on December 1, 2026, we recommend that you move your extension publishing to one of these secure methods.

    Learn more about publishing extensions with vsce.

    Learn more about Trusted Publishing in the Visual Studio Marketplace blog post.

    Deprecated features and settings

    None

    Original source
  • October 2026
    • No date parsed from source.
    • First seen by Releasebot:
      Oct 22, 2026
    • Modified by Releasebot:
      Oct 23, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.143

    Visual Studio Code releases a feature-rich update that makes the Copilot harness the default for new sessions and adds model comparison, on-device AI, worktree cleanup, and improved change navigation. It also brings faster chat loading and expanded enterprise controls.

    Welcome to the 1.143 release of Visual Studio Code.

    Update 1.143.1: The update addresses these issues.

    Release highlights

    This release makes the Copilot harness the default for new sessions and adds tools to compare models, reclaim storage, run models locally, and navigate file changes.

    • Copilot harness by default: The default for new sessions, built on the Copilot SDK, lets you switch between editor and Agents window.
    • Compare models (Preview): Run the same task with multiple models in the Agents window, then compare and combine their solutions.
    • Reclaim worktree storage (Experimental): Free disk space by reviewing and removing inactive agent session worktrees.
    • On-device models (Experimental): Run MAI Code 1.1 Flash locally on your device for your agent tasks.
    • Multi-diff file list (Experimental): Keep an overview of and jump between changed files in the multi-file diff editor.

    Agents

    Copilot harness as the default

    The Copilot harness is now the default for new sessions in VS Code. It's our latest harness, built on the Copilot SDK, a shared foundation that helps align behavior, capabilities, and improvements across Copilot products.

    When you start a new session, Copilot in the harness picker indicates that the session uses the Copilot harness.

    In VS Code, you can keep Copilot harness sessions running in the background and access them from both the VS Code editor window and the Agents window. These sessions run through the Agent Host.

    Thank you so much to everyone who has shared valuable feedback. This release includes more improvements shaped directly by your feedback.

    We're continuing to improve performance and reduce latency based on the scenarios and setups you share. For example, reports of long waits before chat responses helped us reduce delays caused by MCP servers that don't finish loading their tools.

    We're also continuing to make our documentation clearer based on the feedback and questions you've shared. Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post.

    Please continue filing issues to let us know how the Copilot harness is working for you. Your feedback is a huge help and directly shapes the harness experience.

    Initial file-level working set support (Experimental)

    You gave us feedback that when using the Copilot harness, approving or rejecting agent edits in the editor was challenging. As of this release, we are introducing initial file-level working set support to help you manage and review changes more effectively.

    Copilot harness sessions in the editor window now support file-level Keep in the experimental working set above the chat input. Enable chat.editor.workingSet.enabled to try it.

    Select Keep on a file, or in the heading for all files, to mark changes as reviewed and remove them from the working set. The edits stay on disk, and files return if the agent changes them again.

    What's next: We plan to add file-level Undo to the working set and bring Keep and Undo back into the editor for individual changes. These are planned for later releases, landing in Insiders first, then Stable.

    Discard changes from more changesets in the Agents window

    The Changes view in the Agents window lets you see all the modifications made by the agent. Until now, discarding pending changes was only available in the Uncommitted Changes changeset.

    In this release, the Branch Changes, Session Changes, and Last Turn Changes changesets also offer the possibility to discard changes. Select Discard Changes on a file in the Changes view or in the multi-file diff editor. What VS Code discards depends on the changeset:

    • Branch Changes: restores the file to its version where the branch diverged from its base branch, and deletes files that the branch added.
    • Session Changes: reverts the session's edits to the file and keeps changes made outside the session, such as your own edits.
    • Last Turn Changes: reverts only the latest turn's edits to the file and keeps all other changes to it.

    Compare model results (Preview)

    Compare how different models and harnesses approach the same coding task. Run attempts in parallel, review their results, and combine ideas into one solution.

    To get started, enable sessions.chat.compareAgents.enabled in the Agents window, then select Compare Models in the model picker.

    • Choose the approaches to compare: Select two or more models to attempt your task independently. You can mix Copilot, Claude, and Codex harnesses and configure different reasoning levels.
    • Run the attempts: Enter one prompt and start all selected attempts together.
    • Follow progress side by side: Each attempt runs in its own session, so you can compare its approach and open the worktree or changes at any time.
    • Evaluate and combine the results: Optionally select a Judge model to evaluate the attempts and recommend a solution. Its scorecard shows time and token usage, with expandable rationale, validation evidence, and links to each attempt. You can then select Synthesize to build on the recommended attempt with ideas from the others. Synthesis starts only when you request it.

    Tab shortcuts in an empty side pane

    When you closed every tab in the Agents window side pane, the editor area was left blank, and you had to find the Add Tab (+) menu to get back to your session's changes or files.

    The empty editor area now lists the tabs you can add, such as Changes, Files, Browser, and Search, each with its icon and keyboard shortcut. Select an entry to open that tab. If you have a canvas extension installed, a Canvas entry lists the available canvases. When you switch to a session whose editor area is empty, VS Code shows this list instead of reopening the Changes and Files tabs automatically.

    Session Activity Bar (Experimental)

    The Session Activity Bar brings a session's Changes, Files, Browser, and available canvases next to the side pane, keeping these editors and artifacts visually connected to where they open. You can still open session artifacts from the pills at the top of the session.

    The Session Activity Bar is a slim vertical strip of icons at the right edge of the active chat. Select an icon to open that tab in the side pane. If the side pane is closed, it opens with that tab active. If the tab is already open, VS Code focuses it instead of opening a second copy. If you have a canvas extension installed, a Canvas entry opens a submenu of the available canvases.

    You can drag the Session Activity Bar up or down by its grip to move it out of your way, and double-click the grip to reset its position. When you split the chat area, only the focused group shows the Activity Bar.

    To keep session-related layout actions together, right-click the Activity Bar and select Show Layout Actions. This moves the Toggle Side Panel and Toggle Panel actions from the title bar into the Activity Bar.

    The Session Activity Bar is off by default in Stable. Select View > Appearance > Session Activity Bar to turn it on. To hide it again, right-click the Activity Bar and select Hide Session Activity Bar.

    Find and create files from the empty Files tab (Experimental)

    In the Agents window, the Files tab was blank when no file was open, so you had to switch to the Files view to find or create a file in your session's folder.

    When you enable sessions.experimental.emptyFileEditorActions, the empty Files tab shows a search box and a New File action. The search works like Quick Open (Ctrl+P), with the same ranking, highlights, and file icons, and it only finds files in the folders of the current session. Select a result to open it in the editor, or select New File to create a file in the session's folder. When you close the file, the search box returns.

    Improved performance when opening large chats

    Opening a long Agent Host chat in the Agents window used to freeze the window for up to half a minute while the chat's history was restored. In this release, history is restored in small slices instead of one long blocking task, so the window stays responsive. Opening, switching back to, and reloading large chats is significantly faster.

    Reclaim storage from inactive worktrees (Experimental)

    Worktrees are very useful for letting agents work on multiple features simultaneously without interfering with each other's changes. Over time, inactive worktrees can accumulate and consume significant disk space.

    Run Chat: Open Worktree Cleanup from the Command Palette to see how much disk space inactive agent session worktrees use and remove the ones you no longer need. Filter sessions by how long they have been inactive, review each worktree's size, and select the worktrees to clean up.

    Cleaning up marks the selected sessions as done and deletes their worktrees. You can restore a session later to recreate its worktree. Active, running, needs-input, and pinned sessions are protected from cleanup.

    The cleanup editor lets you configure automatic cleanup for sessions with merged pull requests and control whether VS Code suggests cleanup when session storage grows large.

    Models

    Run Copilot models on your device (Experimental)

    Laptops such as the new Surface Laptop Ultra, powered by NVIDIA RTX Spark with up to 128 GB of unified memory, have enough GPU memory to run a capable coding model locally. On-device models let you use that hardware with Copilot: download MAI Code 1.1 Flash from the new On This Device tab in the model picker and chat with it in Copilot harness sessions, with model processing on your device.

    VS Code downloads and manages the model for you. Responses that run on your device are labeled On-device and don't use AI credits. To let Auto route suitable requests to the on-device model with cloud fallback, turn on Use in Auto on the model's details page.

    To get started:

    • Install a llama.cpp build that supports the model
    • Set chat.copilot.localModel.llamaServerPath to its llama-server executable
    • Enable chat.copilot.localModel.enabled

    On-device models require GitHub sign-in and an NVIDIA GPU with 96 GB or more of GPU memory.

    Bring your own OpenAI model to Voice Mode (Preview)

    Use your own OpenAI API key and live model for voice-driven coding conversations instead of the hosted Voice Mode backend. Add your OpenAI key in the Language Models editor, enable agents.voice.enabled, and set agents.voice.useBYOKVoiceModel to a live model ID, like gpt-live-1 that your key can access.

    Sandboxing

    Manage sandbox certificate trust

    Sandbox certificate trust management is available for agent hosts running Windows or macOS.

    The sandbox credential proxy lets tools authenticate to approved services without exposing real authentication tokens to sandboxed processes. It gives tools placeholder credentials, then substitutes the real credentials when forwarding requests to approved destinations. For HTTPS requests, this requires the proxy to present its own TLS certificates, which the tools must trust.

    VS Code shows a dismissible Sandbox trusted CA is not installed notice with an Install option when trust is missing and installation is supported. Installation adds the locally generated CA's public certificate to the Windows machine-wide trust store or the macOS user's login Keychain and can require operating system authorization.

    You can also run Sandbox: Manage Trusted CA from the Command Palette to install, rotate, or remove trust for the last-focused chat's agent host, whether local or remote. Each operation asks for confirmation and identifies the target host. Remove removes operating system trust but keeps the stored certificate and private key. Running tools might need to restart after a certificate change.

    Installation is optional. Missing trust doesn't block chat startup or sending messages, and opening a chat never changes certificate trust.

    Change session sandboxing when policy permits

    If your organization's managed policy permits sandbox bypass, you can turn sandboxing off for an individual Copilot harness session without changing your global settings. Use the Sandboxing for terminal toggle in the session permissions menu in either the editor or the Agents window. Administrators can continue to require sandboxing by disallowing bypass, which keeps the toggle on and locked.

    Chat

    Open canvases from the chat menu (Preview)

    VS Code 1.142 introduced canvases (Preview), which are shared, interactive surfaces for collaborating with agents.

    In this release, you can now open available canvases from New Chat (+) > Canvas in the editor window, without asking Copilot to open them.

    See output from detached background shells

    In Copilot harness sessions, the agent can start commands that need to continue running after it responds in a detached background shell. A dev server or a file watcher are common examples of such commands.

    Detached shells now stream their output like attached shells. Select the Background Shells pill, and then select a detached shell to watch its output as the command runs. You can now also stop detached shells by selecting Stop Shell in the shell's details.

    Editor Experience

    Diagnostic highlight limits

    To improve diagnostic visibility in files with many reported problems, the editor highlight limit has increased from 500 to 5,000 diagnostics per file.

    • Diagnostic source limit: Each extension diagnostic collection can provide up to 1,000 diagnostics per file. If a collection exceeds this limit, the warning indicates that some diagnostics are not shown.
    • Editor highlight limit: The editor highlights up to 5,000 diagnostics per file across all sources. If this limit is exceeded, the warning indicates that only 5,000 diagnostics are highlighted.

    Source Control

    Multi-file diff editor file list (Experimental)

    Navigate changes from commits, stashes, and agent sessions with a file list beside the multi-file diff view. Enable multiDiffEditor.experimental.fileList to try it.

    Each file in the list has a status letter: A (added), M (modified), D (deleted), or R (renamed). As you scroll, the list highlights the file you're viewing. Select a file in the list to jump to its diff. Open Files View & Position in the editor toolbar's More Actions (...) menu to choose View as List or View as Tree, and to place the files On the Left or On the Right of the diffs.

    Enterprise

    Dynamic headers for managed OpenTelemetry

    Administrators can generate and refresh HTTP headers for OpenTelemetry (OTel) exports with the new telemetry.headersProvider managed setting. For example, use a helper to supply short-lived authentication tokens for your collector, without asking developers to update headers manually or opt in through personal OTel settings.

    This setting applies only to Copilot Agent Host sessions. Configure it in enterprise-managed settings, not user settings.

    Managed model defaults

    New Copilot harness chats use your organization's managed defaults, even when you configure chat.defaultModel to another preference. The model picker and setting now explain which defaults apply. You can still change models and supported options per chat.

    Why Local is disabled

    When enterprise policy requires the Copilot harness, the Local harness now stays visible but is disabled in the harness picker, with a Learn why link explaining the restriction.

    Fewer interruptions while organization settings load

    Copilot harness sessions and model changes now wait for slow organization settings to load, with progress and a retry option on failure. You can still select Stop while you're waiting. Organization restrictions apply before requests run.

    Fewer approval prompts for managed tools

    Assisted permissions no longer prompt again for eligible managed tool requests they approve. One-time limits, managed denials, and sandbox restrictions still apply.

    Managed plugins install automatically

    Copilot harness sessions now install or update the agent plugins that your organization requires before using them. Plugins enabled by a trusted repository's settings, and plugins your organization assigns to your team, install in the background without blocking chat.

    Claude and Codex sessions

    When policy requires the Copilot harness, existing Claude and Codex sessions remain visible in the sessions list, so you still can continue them with the Copilot harness. Creating new Claude or Codex sessions remains disabled in this scenario.

    VS Code setup

    Install GitHub Copilot CLI with VS Code

    We now make it easier for you to get started with the GitHub Copilot CLI by letting you install it with the VS Code installer.

    • Windows: The VS Code installer on Windows now includes an option to install GitHub Copilot CLI. If you already have it installed, this option is not presented.
    • Linux: The VS Code Linux installers add a copilot executable into the user path. If you run the copilot command in the terminal, it will either prompt you to install GitHub Copilot CLI if it's not installed, or run GitHub Copilot CLI if it is already installed.
    • macOS: On macOS, you are prompted to install GitHub Copilot CLI when you add VS Code to the $PATH environment variable via the Command Palette in VS Code.

    Deprecated features and settings

    None

    Original source
  • Similar to Visual Studio Code with recent updates:

  • Oct 14, 2026
    • Date parsed from source:
      Oct 14, 2026
    • First seen by Releasebot:
      Oct 14, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.142

    Visual Studio Code releases a major update with preview canvases for agent collaboration, context-preserving chat moves, a more capable Markdown editor, and expanded enterprise controls for agent permissions and sandboxing. It also improves model selection, chat management, and Python environment handling.

    Release highlights

    This release adds shared canvases for agent workflows, lets you move chats without losing context, expands the Markdown editor, and gives administrators more control over agent permissions.

    • Canvases (Preview): Collaborate with agents beyond chat using visual and interactive canvases.
    • Move chats: Continue a chat in another folder or a new Git worktree without losing conversation history.
    • Markdown editor: Work on Markdown files more efficiently with features like pasting images, renaming file links, or breadcrumb navigation.
    • Enterprise management: Enforce agent sandboxing and permission policies while controlling which permission modes developers can use.
    • Redesigned model picker: Quickly switch between Copilot and BYOK contributed models, and manage effort levels and context windows more intuitively.

    Agents

    Copilot harness

    The Copilot harness is powered by the Copilot SDK, a shared foundation that helps align behavior, capabilities, and improvements across Copilot products. In VS Code, the Copilot harness runs sessions through the Agent Host, which lets sessions continue in the background and be accessed from both the VS Code editor window and the Agents window.

    The Copilot harness has been available from the harness picker in the chat input. Based on overwhelmingly positive and valuable feedback, we're progressively rolling it out as the default harness for new sessions in VS Code. When you start a new session, Copilot in the harness picker indicates that the session will use the Copilot harness.

    Thank you to everyone who has shared feedback. We're actively using it to shape the experience. One example is reintroducing Ask as a built-in agent in the Copilot harness. Your feedback showed that a dedicated read-only experience remains valuable. Select Ask from the agent picker to use it.

    Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post. If you have feedback or requests, please file an issue.

    Canvases (Preview)

    Setting: chat.canvases.enabled

    Canvases are interactive interfaces to collaborate with an agent. A canvas opens beside the chat, where you and the agent can inspect and update the same artifact instead of coordinating solely through prompts.

    For example, use a Kanban canvas to plan and track implementation work. You can create and move cards directly, while the agent can break a feature into tasks, update their status, or add newly discovered work. Canvases work in both the VS Code editor window and the Agents window, and canvas extensions are also supported in the GitHub Copilot app.

    Canvases are available in Preview in the VS Code desktop app for local sessions that use the Copilot harness. Enable chat.canvases.enabled, and then start a new session with the Copilot harness.

    Every canvas is provided by a canvas extension. To get started, you have two options:

    • Create a canvas extension: Enter /create-canvas in the chat input and describe the user interface you want for your project. The skill then creates a canvas extension in your workspace and opens its canvas.
    • Install a chat plugin: For now, install a chat plugin that includes a canvas extension through the GitHub Copilot app. Then switch to VS Code and ask the agent to list the available canvases and have it open one.

    After you install a canvas extension, you can also open an available canvas in the Agents window from Add Tab (+) > Canvas.

    Explore and install sample canvas extensions from the community.

    Learn more about canvas support in the VS Code documentation.

    Move chats between folders and worktrees

    Previously, if you started investigating a task in one folder and then wanted to implement it in a Git worktree, or continue in a different repository, you had to start a new chat and rebuild the context.

    In the Agents window, you can now ask the agent to move the current chat to another folder or into a new Git worktree, and it keeps the conversation history intact. Changing the workspace also works for chats that already have a workspace, and the agent can isolate work in a new worktree.

    Ask the agent with a natural-language prompt, for example:

    Continue this task in a new Git worktree of the current repository before implementing it.

    The agent finishes the current turn, moves the chat, and shows a notice when the workspace changes. Then it continues the task automatically in the new location. Edits and commands run in the new location while your original checkout stays unchanged.

    The move is available for agent sessions that use the Codex harness or Codex in Interactive mode, and that contain one chat and one local folder. For prerequisites and details about which files are available in the new location, see Move a chat to another folder or worktree.

    Session-scoped layout in the Agents window (Experimental)

    Setting: sessions.experimental.layoutScope (Agents window only)

    Previously, when you switched between sessions in the Agents window, VS Code shared layout settings such as editor visibility, details, and panel visibility across sessions. If you're used to VS Code remembering the layout for each workspace, sharing the layout across sessions can be disruptive.

    With the new experimental sessions.experimental.layoutScope setting, you can choose how much of the layout each session remembers. Reload the window after you change the setting. It supports the following values:

    • session-shared (default): The current behavior. A session and its nested sessions share the same editors and selected panel views. Editor, details, and bottom panel visibility are shared across existing workspace sessions.
    • chat-shared: A session and each of its nested sessions keep their own editors and selected panel views, while editor, details, and bottom panel visibility stay shared across existing workspace sessions.
    • chat: A session and each of its nested sessions also keep their own editor and details composition and bottom panel visibility.

    Window geometry, pane sizes, and the sidebar currently remain shared across the window.

    Customize the Agents window panel layout

    You can now choose how the bottom panel is aligned in the Agents window. Right-click a panel tab, select Align Panel, and choose one of the following layouts:

    • Center aligns the panel beneath the chat area, leaving more room for the side pane.
    • Justify extends the panel across the full width of the window.

    Your selection is saved per profile and preserved when maximizing or restoring the panel.

    Chat

    Quickly identify the active harness

    Chat titles show the active harness name, such as Copilot or Codex, so you can identify it without opening the harness picker or hovering over the session list.

    Stop background shells

    In Copilot harness sessions, the background shells pill above the chat input lists the commands that the agent is still running in the background. When one of those commands is no longer useful, for example a test run that you want to restart or a command that runs longer than expected, you can stop it instead of waiting for it to finish.

    Select the Background Shells pill, select a shell to open its details, and then select Stop Shell next to its command. Only that command ends, and the shell leaves the list. You can reach Stop Shell with the keyboard, and screen readers announce when the shell stops.

    Stopping a shell is only available for attached shells, which the agent runs as part of its current request. Detached shells run independently of the agent and can't be stopped from this interface.

    Shell details also show each shell's full description above its command, even when the list truncates it. Long output is no longer cut off, and you can scroll back through earlier output, both in the shell's details and in the terminal output in the chat response.

    Stateful responses for BYOK custom endpoints

    If your bring-your-own-key (BYOK) model uses a stateless Responses API, set "statefulResponses": false on its model entry in chatLanguageModels.json to send full conversation history with each request.

    See Custom Endpoint configuration for details.

    Windows sandboxing for Local harness is no longer supported

    Windows sandboxing for terminal commands in Local agent sessions has been deprecated. For sandboxed command execution on Windows, use an Agent Host session. See the Agent Host sandboxing documentation for details.

    Redesigned model picker

    Copilot and bring-your-own-key (BYOK) providers offer many models, each with strengths for different tasks. The redesigned model picker makes it easier to choose and switch models as your work changes.

    The model picker uses a tabbed interface to separate Copilot and BYOK models.

    When you hover over a model in the list, you can further configure its thinking level and context window size.

    Markdown editor

    Editing mode closer to the Markdown source

    When you edit Markdown, each source line appears on a separate visual line, making the document structure easier to follow. Read-only mode continues to render Markdown as before.

    Paste images

    To add an image, for example a screenshot, to your Markdown document, simply paste it directly into the Markdown editor, like you could already do in the text editor. This makes it easier to include visual content without having to save and insert files manually.

    Rename file links

    The Markdown editor now supports Rename Symbol (F2), so you can rename file links in place and have the changes reflected throughout your document.

    Outline and breadcrumbs

    The Markdown editor integrates with the Outline view and breadcrumbs, making it easier to inspect the heading structure and jump to a section.

    Copy code blocks

    Like the Markdown preview, code blocks in the Markdown editor display a copy button on hover. This makes it easy to copy multiline code fragments without accidentally editing the content.

    Editor experience

    Merging document highlights from different providers

    Setting: editor.occurrencesHighlightFromAllProviders

    Enable editor.occurrencesHighlightFromAllProviders to merge document highlights from all providers. By default, VS Code uses highlights only from the highest-priority provider.

    Languages

    Python

    This release includes fixes for environment discovery, interpreter selection, and terminal activation in the Python Environments Extension.

    • Environment discovery: Python installations managed by uv now appear under Global. Selecting an interpreter by path adds its virtual environment to the environment list, and deleting a virtual environment outside VS Code updates the selection.
    • Project-specific environments: Automatic selection now prefers a project's own virtual environment over nested environments. Conda environment selection and Poetry package operations respect project scope, and background refreshes no longer overwrite newer interpreter selections.
    • Interpreter configuration: Fixed resolution of ${workspaceFolder}, relative paths, and commands such as python3 in python.defaultInterpreterPath. The project-view environment selector now includes Enter Interpreter Path.
    • Terminal activation: Shell-startup activation now updates when the global interpreter changes and is preserved when environment files change. Environment-file notifications include Enable for Workspace or Enable for Folder actions.
    • Python installation: When uv is required but missing, setup offers to install it and continues to Python version selection without requiring a PATH refresh.

    Enterprise

    Automatically move policy-managed chats to Copilot Agent Host

    Enterprise managed settings let administrators govern agent permissions and sandboxing. When your organization configures a nonempty permissions object or sets sandbox.enabled to true, VS Code now requires the Copilot harness in Agent Host for full chat sessions, to be able to enforce these policies.

    Opening an existing, unarchived Local chat automatically moves it to Copilot, preserving the transcript and unsent draft, including attachments. Nothing is sent automatically. The new chat uses its normal model and permission defaults under current organization policy.

    VS Code archives the original chat only after the new chat opens successfully. If you switch away while the move is in progress, the original stays unchanged and the unopened destination is removed.

    While these policies apply, Claude, Codex, and terminal chat are unavailable. Editor inline chat remains available for limited read and edit tasks. An empty permissions object or legacy policy alone does not trigger this migration. Administrators can temporarily opt out of automatic migration.

    Temporarily keep the Local harness

    Administrators who need more time to transition to Copilot Agent Host can set vscode.temporaryDefaultToLocalHarness to true in their unified managed settings:

    {
      "vscode": {
        "temporaryDefaultToLocalHarness": true
      }
    }
    

    This keeps the Local harness available and stops automatic switching to Copilot, while preserving explicit, remembered, and current harness choices. Set the managed value to false or remove it to restore normal routing.

    Note: This temporary opt-out also overrides routing required by managed sandbox and permission settings. Local does not enforce those runtime-only rules. Enforcement in Copilot Agent Host sessions is unchanged.

    Manage Copilot permission modes independently

    Administrators can permit Assisted while blocking Allow All, giving developers assisted approvals without bypassing permission checks. The Copilot permission picker reflects the modes permitted by your organization's managed settings.

    For example, merge this configuration into your unified managed settings:

    {
      "permissions": {
        "disableBypassPermissionsMode": "disable",
        "disableAssistedPermissionsMode": false
      }
    }
    

    Use permissions.disableAssistedPermissionsMode to restrict Assisted independently. permissions.defaultMode supplies a starting default, not a restriction on the modes users can select.

    The legacy ChatToolsAutoApprove: false policy still blocks both Allow All and Assisted unless you configure explicit managed mode restrictions. Setting only permissions.defaultMode does not replace that legacy restriction.

    Note: Assisted Permissions is not currently compatible with permissions.{allow,ask,deny}. If you are using any of permissions.allow, permissions.ask, permissions.deny, please set "disableAssistedPermissionsMode": true. In the next release, both will be supported alongside one another.

    Windows numeric policies support DWORD values

    On Windows, policies that accept numeric values support DWORDs and QWORDs.

    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:

    • Stacked pull request support is enabled by default.
    • Conflict-free, locally checked-out pull requests can be updated.

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

    Deprecated features and settings

    New deprecations in this release

    • Windows sandboxing for Local harness is no longer supported

    Thank you

    Contributions to vscode:

    • @bluerose73 (Shengjie Ma): Copilot NES: add ExP toggle to omit max_tokens PR #340327
    • @codelovingcat (Ürem Sancaktutan): Fix/issue 337524 multidiff order PR #337565
    • @denizguney (Deniz Güney Yıldırım): Fix duration calculation for agent stop command PR #338278
    • @na2co3-ftw (na2co3): Modern UI: Prevent vertical scrolling when dragging connected tabs (revised) PR #338180
    • @rksharma-owg (RKS): Preserve newer debugger stop details during continued cleanup PR #339530
    • @sgent-epic: agentHost: preserve BYOK state through tool continuations PR #331749
    • @SimonSiefke (Simon Siefke):
      • fix: memory leak in document paste edits PR #338233
      • fix: memory leak in native context menu dismissal PR #338214
      • fix: memory leak in output channel disposal listeners PR #338240
      • fix: memory leak in debug adapter descriptor factory PR #334103
      • fix: release terminal command history when clearing the normal buffer PR #326931
      • perf: reduce number of strings by 1200 PR #327689
      • fix: memory leak in MainThreadDebugService PR #334102
      • fix: memory leak in extHostTimeline PR #334098
      • fix: memory leak in debug visualization registrations PR #340046
      • fix: memory leak in hidden status bar command arguments PR #338238
      • fix: memory leak in extension host language model providers PR #340579
      • fix: memory leak in terminal disposal subscriptions PR #340037
    • @Tabisharaza (TABISH AYUB RAZA): mcp: read migrated local servers from workspace configuration PR #340034
    • @tuanvtdeptre199: Disable Step Out action when the active thread has only one stack frame PR #336125
    • @tyrielv (Tyrie Vella): Avoid unnecessary --numstat diff for incoming changes decorations PR #339008
    • @yuezhang030: Update VSC model F prompt PR #340187

    Contributions to vscode-pull-request-github:

    • @L4XB (Lukas ): Don't open two browser tabs when clicking the pull request number PR #8962
    • @strawberry-little-bear: Fix malformed issue links in overview HTML PR #9025
    • @vsharha (Viktor Sharha): Fix mergeability polling in pull request overview PR #8954

    Issue tracking

    Contributions to our issue tracking:

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

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

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

    Original source
  • Oct 7, 2026
    • Date parsed from source:
      Oct 7, 2026
    • First seen by Releasebot:
      Oct 7, 2026
    • Modified by Releasebot:
      Oct 13, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.141

    Visual Studio Code releases a major update for AI-assisted development, adding cross-platform agent sandboxing, easier session and worktree management, external Copilot and Codex chat handoff, block pasting, and support for multiple GitHub Enterprise accounts.

    Release highlights

    This release makes it easier to manage agent sessions, protect agent workflows, edit columnar text, and work across GitHub Enterprise instances.

    • Clean up worktree storage: Reclaim disk space from inactive agent session worktrees, on demand or automatically.
    • Cross-platform sandboxing: Limit agent access to files and network resources on Windows, macOS, and Linux with terminal sandboxing.
    • Arrange sessions: Compare and monitor multiple agent sessions side by side in a grid layout.
    • Continue external sessions: Pick up local external Copilot and Codex conversations in VS Code without losing context.
    • Block pasting: Paste block rows across successive lines from a single cursor.
    • Multiple GitHub Enterprise instances: Sign in to GHE.com and GitHub Enterprise Server accounts from the same VS Code window.

    Agent loop

    Copilot harness

    The Copilot harness adds exciting new agent functionality to VS Code. It's powered by the Copilot SDK, so its behavior and capabilities are consistent with other Copilot products, including the standalone GitHub Copilot app and the Copilot CLI.

    To start using the Copilot harness, select it from the harness picker in the chat input. In this release, it might already be the default selection for you. You can continue working as you normally do.

    The harness runs in a dedicated agent host process based on the Agent Host Protocol (AHP), so you can connect to the same agent session from multiple VS Code windows.

    Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post. If you have feedback or requests, please file an issue.

    Reclaim storage from inactive worktrees

    Run Chat: Open Worktree Cleanup to see how much disk space inactive agent session worktrees use and remove the ones you no longer need. Filter sessions by how long they have been inactive, review each worktree's size, and select the worktrees to clean up.

    The cleanup editor also lets you configure automatic cleanup for sessions with merged pull requests and control whether VS Code suggests cleanup when session storage grows large.

    When chat.agentSessions.sessionStorageCleanupSuggestion.enabled is enabled, the Agents window notifies you when enough inactive worktrees accumulate or they use enough disk space to make cleanup worthwhile.

    Cleaning up marks the selected sessions as done and deletes their worktrees. You can restore a session later to recreate its worktree. Active, running, needs-input, and pinned sessions are protected from cleanup.

    Keep track of background shells

    When the agent runs a command in the background, it keeps working on other steps while the command runs. In Copilot harness sessions, a Background Shells pill above the chat input lists the shells that are still running, in both the Agents window and the editor window.

    Select the pill to see each shell's command and how long it has been running, and select a shell to watch its output stream as the command runs, if output is available. A shell leaves the list when its command finishes.

    More control for agent-triggered messages

    When agents delegate work across conversations, they can adjust the delegated task as requirements change instead of waiting for the other session to finish. The send_message tool supports these actions between sessions and nested sessions on the same agent host:

    • Steer an active conversation with a correction.
    • Queue a follow-up as a separate turn.
    • Replace a queued message while preserving its place in the queue.
    • Cancel a queued message before processing begins.

    Queued messages run in order. After a message starts processing, it can no longer be replaced or cancelled.

    Agent UX

    Arrange sessions in a grid

    Compare results, monitor long-running tasks, or work across related conversations without repeatedly switching between sessions. Like in the editor window, the two-dimensional session grid in the Agents window lets you drag sessions into horizontal or vertical splits and resize the panes.

    Maximize a session when you need to focus, then return to the grid to continue working across conversations.

    Compact layout density

    Setting: window.density.layout

    Fit more content in the Agents window with the Compact layout density. Compact density uses a shorter title bar, removes the gaps between workbench parts, and reduces pane spacing.

    By default, the Agents window follows the user-level window.density.layout setting, which also applies to editor windows. To set a different density for the Agents window only, open it and choose View > Layout Density. The density of editor windows remains unchanged.

    Additional session-filtering options

    Focus your sessions list on the work you care about. Open Filter Sessions to filter independently by:

    • Environment: Where the session runs, such as locally, in the cloud, or on a remote host.
    • Harness: Which agent harness the session uses.
    • Created In: Which application created the session, such as VS Code, Copilot CLI, or the Copilot app.

    The menu also brings together ordering, grouping, Show Done, and Created Externally controls.

    Track activity across nested sessions

    Nested sessions let you split related work across separate conversations. In the Agents window, each nested session shows its unread status and last-modified time, helping you find recent activity and conversations that need your attention without opening them individually.

    Status is tracked independently for each conversation:

    • Opening a nested session marks only that conversation as read. An unread nested session does not make the main session appear unread.
    • The last-modified time reflects activity in that conversation, not activity in the main session or another nested session.

    Read status and last-modified times persist when you reload the window or restart VS Code.

    To clear unread status for an entire session tree, right-click the main session and select Mark as Read. Unrelated sessions are not affected.

    Simplified new-session controls (Experimental)

    Settings: sessions.chat.experimental.newSessionComposerLayout, sessions.chat.unifiedWorkspacePicker.enabled (Agents window only)

    The experimental new-session composer keeps your prompt at the center while making session choices easier to review. Workspace, repository, and harness controls now appear in a collapsible Session Options tray above the chat input.

    Getting-started tips now appear in a rounded notice below the chat input, so they no longer separate the session controls from your prompt.

    Collapse the tray to reduce visual clutter without changing your selections. The composer remembers your choice, adapts labels as the window narrows, and keeps the options expanded when screen reader optimized mode is active. When you use a custom chat background, the tray has an opaque surface to keep its controls readable.

    Improved context picker positioning

    The Add Context picker now opens next to the button that invoked it and closes when you select the button again. This keeps the picker visually connected to the chat input in the editor and Agents windows.

    Move agent picker in context control (Experimental)

    Setting: sessions.chat.experimental.agentsPickerInAttachContextMenu (Agents window only)

    If you prefer to have the Agent picker initially hidden from the chat input to reduce the number of controls, you can configure this setting to move it into the Add Context menu. After you select an agent, the picker returns to the chat input.

    Customize new-session welcome messages (Experimental)

    Settings: sessions.chat.experimental.welcomePhrases, sessions.chat.experimental.welcomeMessages (Agents window only)

    New-session welcome messages add personality to the Agents window. In this release, you can add your own phrases to the defaults or replace the default phrases. Use the {name} placeholder to position your welcome name anywhere in a phrase.

    Select Customize Welcome Message beside the heading to change your name or open the phrase setting. You can also right-click the heading and select Hide Welcome Message to turn welcome phrases off.

    Agent environments

    Continue local external Copilot sessions without reloading

    New conversations from the Copilot CLI and GitHub Copilot app are now picked up automatically as external sessions as soon as you send the first request, even when the Agents window is already open. You can open and continue these conversations directly from the Agents window.

    Use the Created In and Created Externally filters to choose which conversations appear in the sessions list.

    Codex chat handoff between apps

    Pick up a Codex chat started in the ChatGPT app or Codex CLI and continue it in VS Code's Agents window on the same machine, with your conversation history intact. You can switch back to the ChatGPT app or Codex CLI later and continue the same chat.

    To use your GitHub Copilot subscription in VS Code, choose a Copilot model in the model picker. For example, you can keep working with Copilot after reaching your ChatGPT usage limit.

    With Codex enabled and Created Externally sessions visible, chats created or updated in ChatGPT or Codex CLI appear within a few seconds without reloading VS Code.

    Only one application can send messages to the chat at a time. If ChatGPT or Codex CLI still has the chat open, a This chat is open in another app banner in VS Code explains why sending is unavailable. Fully quit ChatGPT or exit the Codex CLI session, then select Retry. Your draft and attachments stay in place, and Retry checks access without sending your message.

    Download remote files from the editor

    Save an open remote file locally, without having to navigate for it in the Files panel. In the Agents window, open the editor's More Actions menu and select Download... to download the file to a local destination.

    Dev Container samples (Experimental)

    Setting: chat.agentHost.devContainer.samples.enabled (Agents window only)

    Try an agent with a ready-to-use development environment without first cloning a repository or installing its language tools locally. The Agents window now offers Dev Container samples for Go, .NET, Node.js, PHP, Python, and Rust.

    Install and start Docker, and then enable the setting. Open a new session in the desktop Agents window, select Dev Container Sample from the workspace picker, and send a prompt.

    This also requires chat.agentHost.devContainer.enabled and chat.remoteAgentHostsEnabled to be enabled.

    Agent security

    Sandboxing in the Copilot agent host

    Settings: chat.agent.sandbox.enabled

    Sandboxing gives you more control over what Copilot can access while working on a task. It limits how supported agent operations access files and network resources, and helps to reduce the impact of model mistakes, prompt injection, untrusted dependencies, and locally launched tool servers.

    Depending on the operation and platform, these restrictions use operating-system protections or checks within the agent host process. Sandboxing adds a layer of protection, but does not replace endpoint security or provide a standalone security boundary.

    Sandboxing is available on Windows, macOS, and Linux. On Windows, required operating-system updates must be installed. Refer to Check platform availability for more details.

    To configure sandboxing for all your sessions, enable the chat.agent.sandbox.enabled setting. You can also control sandboxing at the session level with the Sandboxing for terminal toggle in the Permissions menu.

    You can further customize filesystem permissions and network access via their respective settings in VS Code.

    Sandboxing works with both local and connected remote sessions. For local sessions, restrictions are enforced on your machine. For remote sessions, they are enforced on the remote host where Copilot runs tools and commands. Filesystem permissions refer to paths on the machine running the agent.

    Locally launched MCP and language servers are sandboxed by default when sandboxing is enabled.

    Chat experience

    Persistent progress in chat

    Settings: chat.experimental.persistentProgress, chat.experimental.persistentProgressVerbosity

    Persistent progress is rolling out to all users. It keeps in-progress responses visible and lets you control how much progress detail appears. Use chat.experimental.persistentProgress to choose among three icon variants, including a monochrome icon or no icon.

    Meet Blobby

    The /vscode-pet has a name: Blobby. Type /vscode-pet in any chat in the editor or Agents window to meet Blobby.

    Type /blobby to customize Blobby. More customization options become available as you explore chat and unlock achievements.

    Learn more about Blobby and chat pets.

    MCP

    See discovered MCP servers in Customizations editor (Preview)

    Find MCP servers supplied by plugins, extensions, and built-in integrations alongside your configured servers in the MCP Servers section of the Agent Customizations editor. Servers discovered outside your workspace's mcp.json are visible in the UI, so you don't have to use MCP: List Servers to find them.

    Run Chat: Open Customizations from the Command Palette and select MCP Servers to inspect the available integrations. Learn more about adding and managing MCP servers.

    Editor experience

    Frosted glass overlays and menus

    Settings: workbench.modernUIFrostedGlass, workbench.modernUIFrostedGlassOpacity

    Menus, the Command Palette, and other pop-ups now use softly blurred, frosted glass backgrounds in the desktop Agents window. Frosted glass is also available in editor windows when the modernized UI is enabled with workbench.experimental.modernUI.

    Use workbench.modernUIFrostedGlassOpacity to control how much of the blurred content shows through. Lower values make the background more transparent, while higher values make it more solid.

    Frosted glass respects reduced-transparency preferences in VS Code and your operating system, and uses solid backgrounds with high contrast themes or when the effect isn't supported. Disable workbench.modernUIFrostedGlass if you notice display or performance issues.

    Choose your tab style (Experimental)

    Setting: workbench.experimental.modernUIEditorTabStyle

    When the modernized UI is enabled (workbench.experimental.modernUI), you can choose between two tab styles:

    • connected: visually connect the active tab to its content.
    • pill: display tabs as separate rounded pills.

    Spreading block pasting

    Setting: editor.multiCursorPaste

    Paste a copied block at a single cursor to distribute its rows across successive destination lines. This behavior is enabled by default when editor.multiCursorPaste is set to spread. Set it to full to paste the complete block instead.

    Authentication

    Sign in to multiple GitHub Enterprise instances

    Setting: github-enterprise.uris

    Many organizations use GitHub Copilot through a GHE.com account but keep their code on GitHub Enterprise Server (GHES). The github-enterprise.uri setting held a single instance, so you couldn't be signed in to both at once. For example, you couldn't use Copilot with your GHE.com account and review pull requests on GHES in the same VS Code window.

    The new github-enterprise.uris setting takes a list of GHE.com and GHES instances:

    "github-enterprise.uris": [
      "https://octocat.ghe.com",
      "https://github.contoso.com"
    ]
    

    The GitHub Enterprise authentication provider holds accounts from every instance in the list. Each account is labeled with its host, such as monalisa - octocat.ghe.com, so you can tell them apart in the Accounts menu. When more than one instance is configured, signing in asks which instance to use. The order of the entries doesn't select a default instance.

    To check or change which account an extension uses, select Manage Extension Account Preferences... in the Accounts menu, or run Accounts: Manage Extension Account Preferences... from the Command Palette.

    These extensions support multiple instances:

    • GitHub Copilot works with GHE.com instances. When you sign in with Continue with GHE.com, you can enter an instance name, such as octocat, or its full URL. VS Code adds the instance to github-enterprise.uris without removing your other instances, and if an existing entry isn't a valid URL, it offers to fix that entry.
    • GitHub Pull Requests offers to add the host to github-enterprise.uris when you open a repository from an enterprise instance that isn't configured yet. It uses one GitHub Enterprise account at a time, so repositories on your other instances are available after you switch accounts. Using several enterprise instances at the same time is tracked in microsoft/vscode-pull-request-github#9004.
    • GitHub Repositories opens repositories from several GHE.com instances side by side. It doesn't support GHES repositories.

    If you already use github-enterprise.uri, you stay signed in. The first time you launch this release, VS Code moves your stored credentials to work with the new setting.

    github-enterprise.uri is deprecated. When both settings are set, github-enterprise.uris takes precedence, and an empty list ([]) turns off GitHub Enterprise sign-in.

    Enterprise

    Migration of legacy VS Code policies to Agent Host managed settings

    The Copilot harness, powered by the Copilot SDK and running in VS Code's Agent Host, is gradually becoming the default for enterprise users who have VS Code experiments enabled. To preserve existing enterprise controls during this transition, VS Code translates supported legacy policies into unified managed settings at runtime when possible. This translation applies to sessions on the same machine and does not change your policy configuration.

    Enterprises should still migrate to unified managed settings where applicable for consistent policy management across VS Code, the GitHub Copilot app, and Copilot CLI.

    Use managed settings to require sandboxing (Preview)

    To require sandboxing in Copilot Agent Host and prevent bypass, use these unified managed settings:

    {
      "sandbox": {
        "enabled": true,
        "allowBypass": false
      }
    }
    

    Legacy VS Code sandbox settings and device policies are deprecated. ChatAgentSandboxEnabled now supplies an overridable default rather than a mandatory requirement in Agent Host. Local behavior is unchanged.

    Attribute Agent Host sessions to users and machines

    Administrators can more easily attribute Agent Host sessions to users and machines by including operating system usernames and hostnames in VS Code's Agent Host telemetry. Merge this example into your unified managed settings, alongside your existing telemetry exporter configuration:

    {
      "telemetry": {
        "enabled": true,
        "capture": {
          "identity": true
        }
      }
    }
    

    For example, captured identity attributes can include (illustrative values):

    {
      "user.name": "octokit",
      "process.user.name": "devuser",
      "host.name": "dev-workstation"
    }
    

    The OS username (process.user.name) and hostname (host.name) are resource attributes. The signed-in GitHub username (user.name) appears on runtime spans when supported by the bundled Copilot runtime.

    Identity capture is off by default, and the managed value overrides personal preferences. It is independent of content capture. VS Code's host-side control does not govern a runtime's direct exports.

    Keep your selected agent through policy checks

    When your enterprise requires a fresh policy check with forceRemoteSettingsRefresh, chat preserves your selected agent during policy checks instead of switching to Ask or Edit. Routine background refreshes also keep the last accepted policy active while loading. Startup, account changes, and failed refreshes continue to block submissions until policy checks succeed. Newly accepted restrictions continue to apply.

    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:

    • Create, view, and merge stacked pull requests by setting githubPullRequests.experimental.stacks to true.
    • Support for configuring and selecting between multiple GitHub Enterprise instances.

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

    Deprecated features and settings

    GitHub Enterprise URI setting

    The github-enterprise.uri setting is deprecated in favor of github-enterprise.uris, which accepts multiple GHE.com and GitHub Enterprise Server instances. VS Code still reads github-enterprise.uri when github-enterprise.uris isn't configured.

    Legacy VS Code sandbox settings and device policies

    Legacy VS Code sandbox settings and device policies are deprecated. ChatAgentSandboxEnabled now supplies an overridable default rather than a mandatory requirement in Agent Host. Local behavior is unchanged.

    Original source
  • Sep 30, 2026
    • Date parsed from source:
      Sep 30, 2026
    • First seen by Releasebot:
      Sep 30, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.140

    Visual Studio Code adds major AI and agent workflow upgrades, including the Copilot harness, multi-folder sessions, remote delegation, shared worktree reuse, and new enterprise AI controls. It also improves session management, Dev Container startup, and chat usability.

    This release expands agent workflows, improves worktree reuse, and adds enterprise AI controls.

    • Copilot harness: Use the Copilot harness and get consistent agent behavior across Copilot products.
    • Multi-folder sessions (Experimental): Work on tasks across multiple folders within a single agent session.
    • Remote delegation (Experimental): Delegate tasks to connected remote agent hosts.
    • HydraFusion (Research Preview): Let multiple models draft, critique, and revise coding tasks without coordinating them yourself.
    • Shared worktree folders (Experimental): Avoid repeated dependency installs and duplicated artifacts by reusing ignored folders across worktrees.
    • Enterprise controls: Ensure everyone in your org follows AI version requirements and defaults.

    Copilot harness

    The Copilot harness adds exciting new agent functionality to VS Code while keeping the way you work familiar. It's powered by the Copilot SDK, so its behavior and capabilities are consistent with other Copilot products, including the standalone GitHub Copilot app and the Copilot CLI.

    To start using the Copilot harness, select it from the harness picker in the chat input. In this release, it might already be the default selection for you. You can continue working as you normally do.

    The harness runs in a dedicated agent host process based on the Agent Host Protocol (AHP), so you can connect to the same agent session from multiple VS Code windows.

    Learn how to work with the Copilot harness, or explore the architecture and workflows in the agent host blog post. If you have feedback or requests, please file an issue.

    HydraFusion

    HydraFusion is an adaptive model orchestration system that chooses the models and workflow for each coding task. It can solve a task with one model, escalate to a stronger model, or have another model critique and revise the result. This approach aims to improve result quality while balancing speed and cost, without requiring you to coordinate models yourself.

    Eligible users with preview features enabled can select HydraFusion in the model picker.

    Multi-folder sessions

    Multi-folder sessions let you coordinate related work across repositories or isolated worktrees in one session. Previously, every chat in a multi-chat session shared the same folder and checkout. In this release, each chat can use its own folder or worktree without changes leaking between chats.

    Each chat uses its folder for its terminal, tasks, changes, pull request, and Agent merge state. Chats that use the same folder share that state. In the sessions list, hover over a session to see a summary across all its folders, or hover over a nested chat to see details for only its folder.

    Example use cases include:

    • Implement a feature across repositories: Ask the main chat to work in one repository and create a peer chat for a second repository.
    • Compare approaches in separate worktrees: Ask the main chat to create peer chats that each use a fresh worktree of the same repository. Each approach gets its own branch, changes, and pull request.

    Multi-folder sessions are experimental and disabled by default. The settings are not shown in the Settings editor. In your user-scoped settings.json file, set the setting for your harness to true, and then create a session:

    • Copilot: chat.agentHost.copilotAgent.multiRootEnabled
    • Claude: chat.agentHost.claudeAgent.multiRootEnabled
    • Codex: chat.agentHost.codexAgent.multiRootEnabled

    New sessions pick up setting changes without restarting the Agent Host. There is no UI for adding a folder or choosing the folder of a peer chat, so ask the main chat to create the peer chat and describe the repository or worktree it should use.

    Archive chats in a session: Keep the rest of a session active when one chat finishes its work. Because sessions can contain multiple chats, select Mark as Done to archive only the finished peer chat, not the entire session. To restore it with its title and transcript intact, select the Done filter in the sessions list.

    Automatic Dev Container cleanup: When all sessions that use a Dev Container are inactive for five minutes, VS Code stops the container. It restarts automatically when you continue working. Marking as done or deleting the last session removes the container.

    Faster Dev Container startup: Dev Container sessions let agents use your project's tools and dependencies in an isolated environment. Fresh containers can reuse cached VS Code Server and CLI downloads, which reduces setup time and repeated downloads across projects.

    Choose the session relationship and workspace for delegated work: Make two separate decisions when you ask an agent to delegate work. First, decide whether the task belongs to the current session's plan or deliverable. Then specify a workspace only if the task needs repository files, and request a worktree only if file changes need isolation. Related work can still use a different workspace.

    • Create a peer chat for related work: Ask the agent to create a peer chat in the current session. To reuse the current workspace and checkout, say so in your prompt. Because the peer chat shares the checkout, use this option for research, planning, or related work that doesn't need isolated file changes.
    • Create an independent session for unrelated work: Ask the agent to create an independent session with no workspace when a separate deliverable doesn't need repository files. The new session doesn't inherit the source folder. If the work does need a repository, name the project or folder and explicitly request a worktree when its changes need isolation.

    Remote delegation

    Create workspace-less chats on remote agent hosts: Agent Host lets you run and track agent sessions on a remote host. This release adds support for running workspace-less chats on a remote host.

    Select a connected host from the unified workspace picker without choosing a workspace. The Chat entry identifies the selected host, so you can confirm where the session runs before you start.

    Remote folders also appear alongside local folders in the main picker. This makes frequently used remote workspaces easier to select without opening the Remote submenu.

    Delegate tasks to remote agent hosts (Experimental): Your agent can delegate work to connected remote agent hosts from the Agents window, without you selecting a host in a picker for each task.

    The new built-in tools let your agent:

    • Discover hosts, models, resource capacities, and session load with list_agent_hosts.
    • Start a session with create_remote_session. Specify a host, or let automatic placement match an operating system (Windows, Linux, or macOS), minimum memory capacity, logical CPU count, and optional model. Among matching hosts, placement favors the host with the fewest running sessions and pending creations.
    • Check a remote session's status and latest response with get_remote_session.
    • Send follow-up work or report results and questions back to the originating chat with send_remote_message.

    The tools are off by default. Enable this setting along with chat.remoteAgentHostsEnabled and connect the hosts you want to use.

    Personalize new-session welcome phrases

    Personalize new-session welcome phrases (Experimental): Add some personality to the Agents window with an optional welcome heading when you create a new session in the Agents window. The heading shows one of five phrases, such as "What are we building?" or "Let's ship something", and can append your first name from your GitHub profile.

    Welcome phrases are off by default. When enabled, you can use Set Welcome Name from the heading, its context menu, or the Command Palette to choose a different name. The name syncs across devices. Clear it to use your GitHub first name when available, or a generic phrase when your profile has no name.

    Improved session composer controls

    Improved session composer controls (Experimental): The experimental session composer layout reduces the need to move between separate parts of the Agents window. In a new session, the workspace, branch, worktree, and harness controls are grouped above the chat input.

    Enable both settings to use the layout.

    The unified workspace picker also has commands for moving directly to its controls. Use Ctrl+K Ctrl+F to focus the workspace picker or Ctrl+K Ctrl+H to focus the harness picker. Hovers show your configured keybindings, and each picker's context menu provides a Configure Keybinding action. These keyboard improvements require only the unified workspace picker, not the experimental composer layout.

    Starting with this milestone, when you create a new worktree session, the branch picker defaults to the upstream branch of your current branch, such as origin/main. Before creating the worktree, VS Code automatically attempts to fetch the selected remote branch so the session starts from the latest available remote state.

    The picker also loads branches once per workspace and filters them locally, which significantly reduces search latency, especially in large repositories.

    See recently completed sessions first

    See recently completed sessions first: The Done section in the Agents window now sorts sessions by when you marked them as done, with the most recently completed session listed first. This order stays the same when you switch between Created and Updated sorting and after you reload VS Code.

    More reliable agent orchestration

    More reliable agent orchestration (Experimental): Coordination-heavy agent workflows are less likely to stop before the work is complete. This release raises the process-wide limits for agent-created sessions, chats, inter-session messages, and recursive session creation.

    For example, an agent can classify CI failures, delegate each fix to a separate session, and coordinate those sessions without exhausting the message limit before the work is complete. Reaching a limit blocks new orchestration actions but does not interrupt work that is already running.

    The setting defaults to on, and changes apply without restarting the Agent Host. Set it to off to remove the orchestration limits. Confirmation requirements and input validation continue to apply.

    Open a new session in the Agents window from a URL

    Open a new session in the Agents window from a URL: Open the Agents window from another tool or webpage with a workspace and an editable prompt ready for review. Use a URL with the agents/new path and the optional prompt and workspace query parameters.

    For example, this URL opens a new session with no workspace and the prompt already entered:

    vscode://agents/new?prompt=Explain%20how%20this%20project%20runs%20its%20tests.%20Do%20not%20run%20anything%20yet.
    

    VS Code places the decoded prompt in the New Session composer without sending it. To select a workspace, add the workspace parameter with a URL-encoded folder URI. If the URL omits workspace, the draft uses No Workspace. An existing occupied composer remains unchanged, so opening a link does not overwrite work in progress.

    Persistent progress for agent responses

    Persistent progress for agent responses (Experimental): Long-running agent responses are easier to follow with persistent progress. When enabled, chat keeps a progress indicator visible at the bottom until the response finishes.

    Enabling persistent progress also improves the rendering and visibility of in-progress responses. Reasoning appears in separate collapsible previews, and tool calls remain visible while they run. With Compact verbosity, completed tool groups collapse into expandable summaries when response text resumes or the response finishes. Select Verbose to keep the full tool-call details visible.

    Use chat.experimental.persistentProgress to turn the indicator off or choose a colored or monochrome Draw animation. The setting defaults to Draw in VS Code Insiders and is rolling out gradually to Stable.

    Terminal output reflow

    Terminal output reflow: Since VS Code 1.132, terminal output in chat reflows to fit the width of the output preview.

    The new chat.tools.terminal.outputReflow setting lets you control this behavior. If you prefer output to keep a fixed width instead, disable the setting and scroll horizontally to read long lines. Reflow remains enabled by default.

    Use multiple chats in the editor window

    Use multiple chats in the editor window: A session can contain multiple chats. Until now, the main chat with its nested peer chats appeared only in the Agents window. The editor window also shows them: the Sessions view lists the main chat with its peer chats nested underneath, next to the Chat view. Select any row to open that chat in the Chat view.

    Add MCP servers to portable configuration files

    Add MCP servers to portable configuration files: You can add MCP servers to portable configuration files from the MCP: Add Server flow, so you can use the same server configuration across compatible Copilot tools without editing JSON manually.

    For global servers, choose Copilot Global to save the server to $COPILOT_HOME/mcp-config.json, or ~/.copilot/mcp-config.json when COPILOT_HOME is not set.

    For workspace servers, choose .mcp.json to save the server at the workspace root.

    Hear when confetti appears

    Hear when confetti appears: The new Confetti accessibility signal provides the same celebratory feedback when you cannot see the animation. The joyful sound plays when chat thumbs-up confetti appears and when you successfully mark a session as done in the Agents window.

    Explain minimum version requirements

    Explain minimum version requirements: Administrators can require developers to update VS Code before using AI features, for example, to adopt newer sandboxing protections. Instead of an Update Required dialog, VS Code now explains the requirement wherever AI features are unavailable:

    • Chat: shows the required and installed versions, with an update action.
    • Editor window: shows a banner even when Chat is closed. Other editor features stay available.
    • Agents window: shows a blocking overlay, with an Open Editor Window action.

    When an update is available, VS Code offers the matching Check for Updates, Download Update, Install Update, or Restart to Update action. If your organization disables built-in updates by policy, VS Code instead asks you to contact your administrator. The notices clear once the requirement is met. How VS Code enforces the requirement is unchanged.

    Set a default Auto tier

    Set a default Auto tier: The Auto model in VS Code can operate in different tiers, optimizing for efficiency, balance, or intelligence. Administrators can align the Auto model's default behavior with organizational priorities without preventing developers from choosing another tier.

    Administrators can set the default tier for the Auto model with the autoTier managed setting. Accepted values are efficiency, balance, and intelligence.

    The tier applies to new chats in the Local harness and the Copilot agent host on the same machine. The managed tier appears as Default in the model picker.

    The managed tier is a starting point, not a restriction. Developers can still choose a different tier. VS Code keeps explicit and restored choices when the managed tier changes or is removed.

    Capture user identity in OpenTelemetry

    Capture user identity in OpenTelemetry: Organizations can attribute Copilot OpenTelemetry data to individual developers. When identity capture is enabled, Local chat sessions add the following attributes:

    • user.name on agent invocation spans, including subagents and inline chat.
    • process.user.name and host.name as resource attributes.

    Identity capture is off by default and independent of content capture. Administrators control identity capture with the telemetry.capture.identity managed setting (CopilotOtelCaptureIdentity policy). A managed value takes precedence over COPILOT_OTEL_CAPTURE_IDENTITY and user settings. When a policy denies capture, VS Code removes identity from later exports without a reload, including identity attributes that are set explicitly as resource attributes.

    This release also changes how managed telemetry settings are resolved:

    • VS Code applies the telemetry block from only the highest-priority delivery channel: native MDM, then server, then file. Fields that the selected block omits are no longer filled in from lower-priority channels.
    • Managed telemetry.resourceAttributes now take precedence over OTEL_RESOURCE_ATTRIBUTES.

    Note: Identity capture currently applies only to the Local harness. Support for the agent host is tracked in #337413.

    Social media

    Social media: VS Code is now on Instagram! Follow @vscode.ig for VS Code updates, new features, tips, and more.

    Authorization server on authentication sessions

    Authorization server on authentication sessions: The authIssuers proposal lets an extension name the OAuth authorization server it wants to authenticate against, which VS Code introduced for MCP in the 1.101 release notes. This release adds the opposite direction, so a session can tell you which authorization server issued it.

    If your extension talks to more than one deployment of a service, such as public GitHub and a GitHub Enterprise host, you can pair each credential with the destination it was issued for instead of reading a separate setting that the user can change independently. This prevents a valid token from being sent to the wrong host.

    Keep in mind two things. The value identifies an OAuth issuer rather than an API endpoint, so map it to your own endpoints. The built-in GitHub provider populates it for public GitHub sessions as well as enterprise ones, so its presence alone does not make a session an enterprise session.

    Try it out and let us know what you think in the API proposal issue. To learn how to build against a proposal, see using proposed APIs.

    Deprecated features and settings

    Deprecated features and settings: None.

    Thank you

    Thank you: Contributions to vscode include many fixes for memory leaks and improvements across various components, as well as contributions to issue tracking.

    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
  • Sep 23, 2026
    • Date parsed from source:
      Sep 23, 2026
    • First seen by Releasebot:
      Sep 26, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.139

    Visual Studio Code releases faster agent session lists, remote Dev Container support for SSH, Tunnel, and WSL projects, and smoother editing with word wrap indicators and smarter bracket auto-closing. It also adds in-place session renaming, compact session views, and new chat presentation options.

    Update 1.139.1

    The update addresses these issues.

    Release highlights

    This release makes large agent session lists faster, extends Dev Container support to remote projects, and improves everyday editing.

    • Remote Dev Container sessions: Run agents inside your project's Dev Container on SSH, Tunnel, and WSL hosts.
    • Session list improvements: Load large session lists faster, fit more sessions on screen, and in-place session renaming.
    • Editor experience: Identify wrapped lines at a glance and avoid duplicate closing brackets as you type.

    Agents

    The agent host runs agent harnesses in a dedicated process based on the Agent Host Protocol (AHP), so you can connect to the same session from multiple VS Code windows. Learn more about its architecture and workflows in the agent host blog post.

    Run agent sessions in Dev Containers on remote hosts

    Setting: chat.agentHost.devContainer.enabled (Agents Window only)

    Let agents build and test your remote project with the right tools and dependencies, without duplicating toolchain setup on your laptop or the remote host. This release extends Dev Container sessions from local folders to projects on SSH, Tunnel, and WSL hosts.

    To get started, enable chat.agentHost.devContainer.enabled and select Use Dev Container from the folder menu in the Agents Window. The remote folder must have a supported Dev Container configuration, and Docker must be available on the remote host.

    Note: Dev Container sessions are rolling out gradually, so the setting might not be enabled by default for you yet. You can enable the setting manually to try the feature now.

    Faster session list loading

    VS Code loads and refreshes large agent session lists faster. The agent host keeps lightweight session and chat metadata in a central catalog instead of opening every conversation database each time the list is built. Full conversation content remains isolated in the individual session and chat databases.

    The improvement grows with the number of sessions because the previous approach did work in proportion to your session count. Measured with around 645 sessions on a development machine:

    Operation Before After Improvement First session listing after launch 1.3 seconds 0.1 seconds About 12x faster Refresh the session list 0.6 seconds 0.15 seconds About 4x faster

    If you have few sessions, expect a smaller difference. Sessions created before this release are migrated automatically in the background.

    Compact sessions list

    Fit more sessions in the sessions list by enabling Compact View in the sessions list view of the Agents Window.

    Compact rows show the session title at rest and reveal workspace details when you hover over or focus the row. A row expands when the session needs input or approval, so these requests remain visible.

    Progress also appears on the row for the chat that owns the work. When you collapse a session, the parent row summarizes progress from its hidden chats.

    Filter empty session groups

    Disable Empty Groups from Filter Sessions to hide empty custom groups and the empty Chats section. This preference is stored in your profile and resets with the other sessions list filters.

    Rename sessions and chats in place

    Rename a session or nested chat directly in the sessions list. Double-click its title, use the Rename context menu action, or focus the row and press F2 for a session or F2 for a nested chat. Inline validation prevents blank titles, and canceling restores the previous title.

    Choose how chats appear in a session (Preview)

    Setting: sessions.showChatTabs (Agents Window only)

    An agent session can contain multiple chats, each representing a different conversation or context. When a session contains multiple chats, choose the presentation that best fits your workflow from the session header menu:

    • Multiple shows each chat on its own tab.
    • Single shows only the active chat and hides the tab bar.

    Switching presentations preserves your open chats, active chat, and conversation state. In Single mode, chats that you explicitly open to the side remain independent panes with their own header actions.

    Pet naming contest update (Experimental)

    Thank you to everyone who submitted a name for the VS Code pet. The naming contest closed on September 17, 2026, and we're reviewing the eligible entries. We'll announce the winner and the pet's new name soon.

    While you wait, enter /vscode-pet in chat to meet your companion and explore all its interactions and reactions.

    Editor experience

    Word wrap indicators

    Display word wrap indicators to make wrapped lines easier to identify. An arrow at the word wrap column on the right side of the editor indicates that a line wraps.

    Improved bracket auto-closing behavior

    VS Code avoids inserting duplicate closing brackets when you type an opening bracket. If a matching closing bracket exists, VS Code uses it. Otherwise, VS Code inserts one.

    Proposed APIs

    Access token lifetime on authentication sessions

    AuthenticationSession exposes an access token but no information about how long that token stays valid. An extension that passes a credential to an SDK with its own refresh callback cannot distinguish between a token that never expires and one that is about to expire. As a result, the extension either refreshes the credential unnecessarily or lets a long-running operation fail when the token expires.

    The authSessionExpiration proposal adds an optional expiresAfter property to AuthenticationSession:

    export interface AuthenticationSession {
      /**
       * The access token's remaining lifetime, in milliseconds, when the authentication
       * provider returns the session.
       */
      readonly expiresAfter?: number;
    }
    

    The value is the remaining lifetime when the session is returned rather than an absolute expiration timestamp. The extension host can run on a different machine than the client, and the two clocks can disagree. Authentication providers that return a cached session recompute the value each time and leave it undefined when the token's expiration is unknown. The built-in Microsoft account provider supplies this value.

    Try it out and let us know what you think in the API proposal issue. To learn how to build against a proposal, see using proposed APIs.

    Deprecated features and settings

    Linux desktop launcher names

    If a pinned launcher stops working after updating to version 1.139, remove it and add the application again from your desktop's application menu.

    The Linux DEB and RPM packages now use reverse-DNS desktop file names to align with the application's desktop identity. For the Stable packages, the files in /usr/share/applications/ are renamed as follows:

    Previous name New name code.desktop com.microsoft.VSCode.desktop code-url-handler.desktop com.microsoft.VSCode.UrlHandler.desktop

    Existing favorites, pinned launchers, and custom references to the old names are not updated automatically. On KDE Plasma, a stale favorite can report "You are not authorized to execute this file" even though this is a missing desktop file, not a permissions problem.

    • Remove the old favorite or pinned launcher, then add the application again from the application menu. On KDE Plasma, use Remove From Favorites on the old entry, then Add to Favorites on the entry under Applications > Development.
    • Update custom shortcuts and scripts that reference the old desktop file names.
    • If you explicitly configured file or URL associations using the old IDs, select the application again in your desktop's default-application settings.

    You can still start the application from a terminal with code. Reinstalling the package does not update saved references to the old names.

    Notable fixes

    • For users whose organization disables Agent mode by account policy, ensure the Welcome invitation opening is hidden and that alternative methods of launching the disabled Agents Window (for example, code --agents disallow circumvention of the control). Fix account policy enforcement in the Agents window.
    • For users with enterprise-managed OpenTelemetry (OTel) settings, fix a race condition in the configuration of OTel in the Local (i.e. non-Agent Host Harness) to ensure OTel is not dropped. Fix Enterprise Managed OTel Race in Copilot Extension.

    Thank you

    Contributions to vscode:

    • @AnupamKumar-1 (Anupam Kumar): fix(chat): preserve #file reference when editing text before it PR #333965
    • @baywet (Vincent Biret): feat: adds the default openapi file match for the JSON extension PR #336273
    • @brandonh-msft (Brandon H): Fix remote chat plugin paths PR #326916
    • @brignano (anthony): github-authentication: skip education.github.com check for EMU accounts PR #336608
    • @Chirag-Bhardwaj (Chirag Bhardwaj): Fix clearing custom terminal titles PR #336599
    • @dobbydobap (varshitha): Show active editor language first in Configure Snippets PR #324369
    • @emxs1 (Emma): add more fun working messages PR #335600
    • @jlelong (Jerome Lelong): Latex : update language configuration PR #332303
    • @joltcoke (Florian Schirmer): Guard navigator.clipboard in the WebKit clipboard workaround PR #334878
    • @joshspicer: Fix permission bits in mock-policy-server file commands PR #334382
    • @Muszic (Sangeet): Add upstream Cargo completion spec for terminal suggestions PR #305309
    • @SimonSiefke (Simon Siefke): fix: memory leak in document drop edits PR #336025, fix: memory leak in dialog main service PR #336019, fix: memory leak in notebook attachment diagnostics PR #333383, fix: memory leak in signature help PR #336020, fix: memory leak in extension host hierarchy PR #336023, fix: memory leak in issueReporterOverlay PR #335102, fix: memory leak in workspace symbols PR #336029, fix: memory leak in extension host speech PR #336021, fix: memory leak in notification action view items PR #333340
    • @yoavbls (Yoav Balasiano): Allow display:inline-block on spans style PR #180498

    Issue tracking

    Contributions to our issue tracking:

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

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

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

    Original source
  • Sep 16, 2026
    • Date parsed from source:
      Sep 16, 2026
    • First seen by Releasebot:
      Sep 17, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.138

    Visual Studio Code releases an agent-focused update with Dev Container sessions, expanded Codex support, and cleaner session management. It also adds automation sharing, pull request creation from agent sessions, attention badges, and refreshed chat background and Voice Mode controls.

    Welcome to the 1.138 release of Visual Studio Code.

    This release helps agents work in your project's development environment, gives Codex sessions more flexibility, and keeps completed sessions organized.

    • Agent sessions in Dev Containers: Run agents with your project's tools and dependencies in a local Dev Container.
    • Expanded Codex harness: Continue Codex sessions across apps, choose between Copilot and ChatGPT subscriptions, and use VS Code tools.
    • Session cleanup (Preview): Automatically mark merged sessions as done and optionally delete them after a grace period.

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

    Happy Coding!

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

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

    Agents

    The agent host runs agent harnesses in a dedicated process based on the Agent Host Protocol (AHP), so you can connect to the same session from multiple VS Code windows. Learn more about its architecture and workflows in the agent host blog post.

    Automations are now enabled by default and can be shared

    Settings: chat.automations.enabled (Agents window only)

    Automations are now enabled by default, making it easier to streamline repetitive tasks. You can also export and import automations to share them across different environments or with your team. Learn more about Automations in the VS Code docs.

    Run agent sessions in local Dev Containers

    Setting: chat.agentHost.devContainer.enabled (Agents window only)

    Keep agent work aligned with your project's toolchain by running a session inside a local folder's Dev Container. The agent uses the environment and dependencies configured for the project instead of those on your local machine.

    When the setting is enabled, local folders with a supported Dev Container configuration automatically show a folder menu with a Use Dev Container action. Select the action to run the agent session in the folder's Dev Container. Docker must be installed on your machine.

    Note: Local Dev Container sessions are rolling out gradually, so the setting might not be enabled by default for you yet. You can enable the setting manually to try the feature now.

    Expanded Codex support in the agent host

    Settings: chat.agentHost.codexAgent.enabled (This setting can be configured by an organization policy.), chat.editor.codex.preferAgentHost

    This release expands Codex support in the agent host, so you can keep the same coding session while changing where and how you work.

    • Choose your subscription: use Codex with a GitHub Copilot subscription or a ChatGPT subscription. If you sign in to both, switch between Copilot-backed and ChatGPT-backed models from the model picker without losing the current conversation.
      • If you are not signed in to GitHub Copilot and want to use the Codex harness just with your ChatGPT subscription, you also have to enable chat.agentHost.allowSignedOutWhenUsable.
    • Continue across apps: move the same Codex session between the ChatGPT app and VS Code instead of starting a new conversation.
    • Interact with desktop apps from VS Code: if the ChatGPT app is installed and configured for computer use, the Codex harness in VS Code can reuse that setup to interact with apps on your computer. This works with models from either your Copilot subscription or your ChatGPT subscription.
    • Use VS Code tools: Codex can use the full set of tools provided by VS Code, including built-in, extension, and MCP tools. With a ChatGPT-backed model, Codex can also use its image-generation tool directly in the session.

    Continue Codex quick chats in a workspace

    Last release, we introduced continuing quick chats in a workspace for Copilot sessions. This release extends the same flow to Codex, so starting project-specific work no longer means abandoning a workspace-less Codex quick chat. Ask Codex to attach a local folder, then choose whether to use the folder directly or create an isolated worktree.

    After you confirm the change, the same chat and native Codex thread become a workspace session. The session retains its title, conversation history, current request, selected model, and permission mode. Codex then continues the request with access to the project files.

    Workspace conversion is available for idle Codex quick chats in Interactive mode and supports single-root workspace targets. If the change is canceled or cannot be applied, the original workspace-less chat remains available.

    On-demand agent SDK downloads

    The Claude and Codex agents in the Agents window rely on an SDK that is not shipped with VS Code and is downloaded when you first need it. Previously, the offer to download it appeared only as part of signed-out account setup, so if you were signed in it would download at first message.

    The offer now appears whenever the SDK is missing for transparency that a download is needed to continue.

    When models are already available for that agent, the notification presents two options: select Download or send a message to download the SDK as part of the turn. The wording updates in place if models become available while the notification is showing.

    Create pull requests from agent sessions

    Setting: chat.agentMerge.enabled (optional, for Agent Merge only)

    Create pull requests from Agent Host sessions in the Agents window using one form to review and edit generated titles and descriptions, choose draft status, and configure available merge options. Create the pull request directly or send the request to your agent, with your preferred options remembered for next time.

    Note: The Agent Merge option is experimental and is only available when the setting above is enabled.

    Keep completed sessions organized (Preview)

    Settings: chat.agentSessions.archiveNudge.enabled, chat.agentSessions.autoMarkAsDoneMergedSessionsAfterDays, chat.agentSessions.autoDeleteArchivedMergedSessionsAfterDays, sessions.markAsDoneConfetti (Agents window only)

    Keep finished work out of the way while preserving the conversation for later. When all of an inactive session's pull requests have merged, the Agents window can suggest marking the session as done. A first-use guide shows you where to find Mark as Done in the sessions list.

    Enable chat.agentSessions.archiveNudge.enabled to show these suggestions.

    To automate cleanup, mark inactive sessions as done after their pull requests merge, and optionally delete them after a separate grace period. Both automatic-cleanup settings are disabled by default.

    When all pull requests for a session are merged, select Configure Automatic Cleanup in the Mark as Done suggestion to open both settings without enabling them.

    Enable sessions.markAsDoneConfetti to show a confetti animation when you mark a session as done. The animation respects your reduced-motion preference.

    See which sessions need attention (Preview)

    Setting: sessions.showApplicationBadge (Agents window only)

    See when agent sessions need your attention without switching back to VS Code, with a badge on the macOS dock, Linux launcher, or Windows taskbar. The badge highlights sessions with new results, requests for input, or pull request checks that need attention.

    Enable the preview setting above to show the badge.

    Unified workspace and repository picker (Experimental)

    Setting: sessions.chat.unifiedWorkspacePicker.enabled (Agents window only)

    Start agent work from one searchable list of local folders, GitHub repositories, Cloud repositories, and remote targets. Remote connection actions remain available from the Remote entry.

    Selecting Work in Repository uses a cloud-first workflow. A GitHub repository that is not already local is selected immediately with the Cloud harness, without a clone prompt. If you later choose a local harness, VS Code prompts you to clone the repository and preserves the cloud selection if you cancel.

    Customize chat backgrounds by color theme (Experimental)

    Settings: chat.agentSessions.preferredDarkBackgroundImageLayout, chat.agentSessions.preferredLightBackgroundImageLayout (Agents window only)

    The Agents window can show a decorative chat background behind your sessions, either a pattern of built-in VS Code icons or an image of your own, chosen separately for dark and light color themes.

    Previously, the image was per theme kind but its layout was not, so right-aligning your dark background and then left-aligning your light one left both of them aligned left. Layout is now stored per theme kind alongside the image, and switching between a dark and a light theme restores that theme's placement. The two new settings replace chat.agentSessions.backgroundImageLayout.

    Clearing a background also moved. Chat: Set Background... now leads with No Background, which clears the background for the color theme you are currently using and leaves the other one alone.

    Response and request surfaces are opaque, so higher-contrast backgrounds do not reduce the readability of agent responses.

    Improved Voice Mode session awareness (Experimental)

    Navigate and monitor parallel agent work without leaving Voice Mode. Voice Mode can find recent agent sessions, switch between them by label, and report each session's status.

    Deprecated features and settings

    New deprecations in this release

    • chat.agentSessions.backgroundImageLayout is replaced by chat.agentSessions.preferredDarkBackgroundImageLayout and chat.agentSessions.preferredLightBackgroundImageLayout, so that the Agents window chat background layout can be set separately for dark and light color themes.
    • Chat: Clear Background is removed. Choose No Background in Chat: Set Background... to clear the background for the current color theme.

    Thank you

    Contributions to vscode :

    • @denizguney (Deniz Güney Yıldırım): Update completion test for files.exclude configuration PR #332809
    • @DhineshPonnarasan (Dhinesh Ponnarasan): Fix completed progress notification dismissal PR #315184
    • @jacobjove (Jacob T. Jove): Fix main process OOM from unconsumed buffered pty host service events PR #323980
    • @RyanEwen (Ryan Ewen): Keep Codex MCP tool progress out of the tool result PR #334053
    • @SimonSiefke (Simon Siefke): fix: memory leak in markers table PR #333241
    • @vladstudio (Vlad Gerasimov): Fix terminal-editor shift-drop firing on detached instances PR #318756
    • @vscodebot-pr (VS Code PR Bot): fix: resolve win32 product.json path in native policy smoke fixture (build fix for vscode-engineering#3813) PR #335152
    • @yutotnh (yutotnh): Force commit messages output to UTF-8 PR #331087
    • @zhichli (Zhichao Li): docs: align OTel guidance with Agent Host architecture PR #335175

    Contributions to vscode-chat-customizations-evaluation :

    • @JakLuminth (Jacob Searcy): Fix language client startup with a log output channel PR #286

    Issue tracking

    Contributions to our issue tracking:

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

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

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

    Original source
  • Sep 9, 2026
    • Date parsed from source:
      Sep 9, 2026
    • First seen by Releasebot:
      Sep 14, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.137

    Visual Studio Code releases 1.137 with stronger AI-assisted workflows, adding recurring automations, experimental voice chat with agents, smoother workspace chat continuation, and tighter GitHub issues and pull request integration in the Agents window, alongside diff and editor improvements.

    Welcome to the 1.137 release of Visual Studio Code. This release helps you automate recurring work, continue quick chats in a workspace, talk with agents by voice, and work with GitHub issues and pull requests without leaving the Agents window.

    • The Story of VS Code: Watch the VS Code documentary and discover how the editor and its community evolved.
    • Automations (Preview): Schedule recurring agent tasks to run hourly, daily, or weekly, or run them on demand.
    • Voice Mode (Experimental): Talk with an agent and interrupt or redirect it while it works on your code.
    • Continue quick chats in a workspace: Attach a project to an existing quick chat without losing the conversation history or current request.
    • GitHub issues and pull requests (Experimental): Review issue and pull request details directly in the Agents window, even when the repository is not open.
    • Contest: Name the VS Code pet: Meet the VS Code pet and enter the contest to choose its name.

    Don't forget to join the GitHub Copilot Day live on September 10, 2026. Learn the most effective ways to use Copilot, from agents and model choice to working across GitHub, Copilot app, Copilot CLI, and Visual Studio Code.

    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.

    The Story of VS Code

    Discover the story behind VS Code, from its early beginnings to the platform millions of developers use today, and the community that helped shape it along the way.

    Agents

    Automations (Preview)

    Setting: chat.automations.enabled

    Automations run recurring agent tasks on a schedule, so routine work does not have to be started manually. Start with a template for catching up on changes, triaging issues, or finding bugs, or define your own prompt and schedule.

    To try automations, enable chat.automations.enabled, open the Agents window, and select Automations in the sidebar. You can run an automation on demand or schedule it to run hourly, daily, or weekly. Learn more about automations in the documentation.

    Automations is in Preview and is rolling out gradually to all users.

    Open GitHub issues and PR details (Experimental)

    Setting: extensions.experimental.enableAgentsWindowCapability

    When a chat conversation references work on GitHub, the Agents window can provide direct integration with the GitHub Pull Requests extension. Select a github.com issue or pull request link to open its details directly in the Agents window, without switching to a browser. This also works when you don't have a workspace for that repository open.

    To try this initial integration, install the GitHub Pull Requests extension in your default VS Code profile and enable extensions.experimental.enableAgentsWindowCapability.

    Attach GitHub issues and pull requests in any chat

    Add a GitHub issue or pull request as context from the Add Context... menu in any chat input, including the Chat view, Chat editor, and Agents window. This makes the issue description, comments, or pull request changes available to the agent without copying them into your prompt.

    You can also paste a GitHub issue or pull request URL into the new-session input. The URL remains in your prompt and a context attachment is added automatically.

    Help name the VS Code pet (Experimental)

    The experimental VS Code pet is an interactive companion that reacts as you work with agents. Enter /vscode-pet in chat to meet it, then help choose its name.

    From September 10 through September 17, 2026, submit a name for the VS Code pet. Review the contest terms and conditions.

    Continue quick chats in a workspace

    You can start a quick chat in the Agents window without associating it with a workspace, for example, to discuss general questions or ideas. If the conversation later becomes project-specific, ask the Copilot agent to attach a local folder and continue the same chat.

    After you confirm the workspace and choose whether to use the folder directly or create an isolated worktree, the chat becomes a workspace session. The session retains its title, conversation history, and current request, and the agent automatically continues with access to the project files when workspace setup finishes.

    Note: Continuing a chat conversation in a workspace session is currently available only in the Copilot harness.

    Agent-queued messages

    Keep agents working in parallel without interrupting a chat that is already processing a request. When an agent uses the send_message session-management tool to contact a busy chat, VS Code queues the message and starts it after the active turn completes successfully.

    An agent can queue multiple messages for chats in the same session or another session. VS Code processes queued messages in the order they were sent, making multi-chat workflows more predictable.

    Agent host

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

    We're actively developing the agent host. Learn more in the agent host documentation and our agent host blog post, where we share why we built the agent host, what it enables in VS Code, how the architecture and open protocol work, and workflows you can try yourself.

    If you have any feedback or requests, please let us know by filing an issue.

    Chat

    Voice Mode (Experimental)

    Settings: agents.voice.enabled, agents.voice.showTranscript, agents.voice.voice

    Voice Mode enables you to have a natural, spoken conversation with an agent while it works on your code.

    Note: Voice Mode is rolling out gradually and might not be available to every eligible account immediately. It requires an eligible individual GitHub Copilot plan and is not available with GitHub Copilot Business or GitHub Copilot Enterprise. Organizations can also turn off Copilot preview features by policy.

    To try it, enable agents.voice.enabled and select the Voice Mode button in the chat input.

    While the agent is speaking, start speaking or use the push-to-talk shortcut to interrupt the response and continue the conversation.

    Voice Mode is aware of your active session and can answer questions about running sessions, the selected model, and attached files. You can also ask Voice Mode to start a new session. When a request is routed, Voice Mode announces whether it is sending the request to an existing session or starting a new one.

    You can customize Voice Mode in the following ways:

    • Enable agents.voice.showTranscript to show the conversation transcript in the chat input while Voice Mode is active. Use the Voice Mode controls to show or hide the transcript and mute or unmute your microphone without ending the voice session.
    • Run Chat: Dictate: Select Microphone from the Command Palette to choose the input device used by both dictation and Voice Mode.
    • Use agents.voice.voice to select the voice that reads responses aloud.
    • Run Voice Mode: Show Introduction from the Command Palette to reopen the introduction, where you can select a microphone and preview the available voices.

    You can also right-click the Voice Mode button in the chat input to quickly access its configuration, instructions, introduction, microphone selection, and transcript controls. Learn more about using Voice Mode.

    Code Editing

    Smart diff editor layout

    Choose a diff layout in the same way across regular diffs, multi-file diffs, and the Agents window Changes editor. Open More Actions (...) > Diff View, and then select Inline, Side by Side, or Automatic.

    The Automatic option shows which layout is active and adapts as the editor width changes. If you deliberately widen an inline diff by dragging a sash, the diff remains inline while you resize so the content doesn't shift unexpectedly.

    Binary files in multi-file diffs

    Changed binary files, such as images, remain visible in multi-file diffs instead of being omitted. The diff shows a Binary file changed placeholder in the file's original position. Select Open Diff to review the file in the standard diff experience, such as an image diff or applicable custom editor.

    Multi-file diffs in editor windows also use the same visual design as multi-file diffs in the Agents window.

    Languages

    GitHub links in the Markdown editor (Experimental)

    Settings: markdown.experimental.richLinks.enabled, chat.experimental.richLinks.enabled

    GitHub issue and pull request links in the Markdown editor show the current title and state, so you can understand each reference without opening it first. The link updates when its issue or pull request state changes, including CI updates.

    To use the same link rendering in chat, set chat.experimental.richLinks.enabled to true.

    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:

    • Faster opening of the pull request webview
    • All github.com links in VS Code will be opened with the extension (can be disabled with githubPullRequests.openPullLinks)

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

    Deprecated features and settings

    None

    Thank you

    Contributions to vscode:

    • @accnops (Arthur Cnops): Use dedicated MAI transcription for dictation PR #334042
    • @arpankanwer (Birarpanjot Singh Kanwer): fix(copilot): don't auto-retry expired vision attachments, show actionable error PR #334129
    • @bstee615 (Benjamin Steenhoek): Recognize eagerness option in PatchBased02Unified PR #333606, Add PatchBased02UnifiedEagerness prompt strategy PR #333302
    • @hadley (Hadley Wickham): Fix webview view badge not clearing when set to undefined PR #331019
    • @jmymay (Jeremy Majewski): Add isChromeOS to platforms.ts and context. PR #309097
    • @joshspicer: agentHost: managed permission fixes for shell paths and read prompts PR #333249, Managed settings: reuse cached policy more often PR #333697, Improve mock policy server troubleshooting PR #333930, Ensure managed settings stability with regression tests PR #334056, Polish mock policy server UI PR #334122, remove old tool-rename-deprecation skill PR #334279, remove example from mock-policy-server PR #334361
    • @kondv: mcp: Avoid stopping servers for equivalent URI definitions PR #333443
    • @leep-frog: add args to editor.action.formatDocument.multiple PR #245743
    • @mcumming (Michael Cummings (MSFT)): Enable Microsoft Entra ID sign-in for Private Marketplace access PR #325331, Make extensions.gallery.authProvider policy-controlled PR #333837
    • @mst-mkt (keito): Fix surrounding a selection with brackets after arrow functions (#_225916) PR #321210
    • @piyushmadan (Piyush Madan): Show remaining turns to execution subagents PR #332704
    • @RajeshKumar11: Fix extensions.allowed schema flagging valid version arrays as invalid PR #329744
    • @rohit489 (Rohit Agrawal - MSFT): Record CAPI X-Copilot-Service-Request-Id on chat telemetry events PR #334638
    • @RyanEwen (Ryan Ewen): Report a browser tool failure with an empty message as a failure PR #334311
    • @SimonSiefke (Simon Siefke): fix: memory leak in git branch protection provider PR #333381, fix: memory leak in extension host pseudoterminals PR #333397, fix: memory leak in accessible view toolbar PR #333183, fix: memory leak in test results PR #333244, fix: memory leak in extension host comments PR #334095, fix: memory leak in mainThreadNotebook PR #334189, fix: memory leak in terminal profile service PR #334100
    • @vscodebot-pr (VS Code PR Bot): fix: clamp inverted visible range in ListView to prevent RangeError (fixes #333230) PR #333236, fix: cancel pending single-pane docked-tab reconciles on dispose (fixes #333537) PR #333541, fix: guard null diagnostic code in copilotcli diagnostics push (fixes #333772) PR #333781, fix: skip real AudioContext in Voice Mode onboarding preview under tests (build fix for vscode-engineering#3742) PR #333858
    • @wibaek (Wibaek Park): fix: avoid refocusing find input during IME composition PR #320898
    • @YOSHII-Hiroto (吉井 啓人(YOSHII, Hiroto)): Support opening MHTML files in integrated browser PR #333307

    Contributions to vscode-pull-request-github

    • @jameswilmiller (James Miller): Always show commit SHA in tree PR #8840
    • @tamird (Tamir Duberstein): Require variables for legacy GraphQL queries PR #8889, Retry review comments with smaller pages PR #8890

    Issue tracking

    Contributions to our issue tracking:

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

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

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

    Original source
  • Sep 9, 2026
    • Date parsed from source:
      Sep 9, 2026
    • First seen by Releasebot:
      Sep 9, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.137

    Visual Studio Code ships the 1.137 release with new ways to automate recurring work, continue quick chats in a workspace, talk to agents by voice, and review GitHub issues and pull requests in the Agents window.

    Welcome to the 1.137 release of Visual Studio Code. This release helps you automate recurring work, continue quick chats in a workspace, talk with agents by voice, and work with GitHub issues and pull requests without leaving the Agents window.

    The Story of VS Code

    Watch the VS Code documentary and discover how the editor and its community evolved.

    Automations (Preview)

    Schedule recurring agent tasks to run hourly, daily, or weekly, or run them on demand.

    Voice Mode (Experimental)

    Talk with an agent and interrupt or redirect it while it works on your code.

    Continue quick chats in a workspace

    Attach a project to an existing quick chat without losing the conversation history or current request.

    GitHub issues and pull requests (Experimental)

    Review issue and pull request details directly in the Agents window, even when the repository is not open.

    Contest: Name the VS Code pet

    Meet the VS Code pet and enter the contest to choose its name.

    Don't forget to join the GitHub Copilot Day live on September 10, 2026. Learn the most effective ways to use Copilot, from agents and model choice to working across GitHub, Copilot app, Copilot CLI, and Visual Studio Code.

    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.

    Original source
  • Sep 2, 2026
    • Date parsed from source:
      Sep 2, 2026
    • First seen by Releasebot:
      Sep 2, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.136

    Visual Studio Code releases 1.136 with agent-focused updates for finishing pull requests, managing multi-root workspace sessions, organizing related chats, and personalizing the Agents window. It also brings improved editor, browser, terminal, and accessibility experiences.

    Welcome to the 1.136 release of Visual Studio Code. This release helps you finish pull requests with agents and manage agent work across complex workspaces and related chats.

    • Agent Merge (Preview): Resolve review feedback, failed checks, and merge conflicts until your pull request is ready to merge.
    • Multi-root workspaces (Experimental): Work with Copilot and Claude agent sessions across all folders in a multi-root workspace.
    • Chat backgrounds (Experimental): Personalize the Agents window with built-in patterns or your own images.
    • Chat sessions: Organize related chats in a session hierarchy and quickly see which ones need your attention.

    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.

    The Story of VS Code: World Premiere

    Discover the story behind VS Code, from its early beginnings to the platform millions of developers use today, and the community that helped shape it along the way.

    Premiere: September 4 at 8:00 AM PT. Join us!

    Agents

    Multi-root workspaces in editor window (Experimental)

    Settings: chat.agentHost.copilotAgent.multiRootEnabled, chat.agentHost.claudeAgent.multiRootEnabled

    Copilot and Claude agent sessions in the editor window Chat view support multi-root workspaces.
    This capability is currently scoped to the editor window.
    Agent hooks remain scoped to a single workspace folder. If hooks are detected in multiple folders, VS Code prompts you to select the primary folder from which to load them.

    Redesigned new-session input

    Start delegated work with less setup in the redesigned new-session input. The updated experience brings the prompt, model selection, workspace selection, and other session controls together in one layout.

    Improved workspace resolution

    Agents can resolve workspaces by their project name in addition to absolute paths and workspace URIs. Session tools also preserve project URIs and all working directories for multi-root workspaces.

    As a result, you can make requests such as "run this in the vscode workspace" without providing a full path. If multiple workspaces have the same name, the agent reports the possible matches instead of silently choosing one. Remote workspace URIs are supported as well.

    Navigate related chats and sessions

    Keep related agent work organized and move between sessions and chats from the sessions list in the Agents window. Chats appear as children of their parent session, so you can understand which chats belong together without managing a collection of unrelated sessions.
    Each chat row shows its own title, status, and pending approvals, so you can see which chat needs your input. Expand or collapse the hierarchy, and open, rename, move, or delete individual chats directly from the tree.
    When an agent delegates independent work to multiple chats, each created chat gets a meaningful title and appears in this hierarchy.

    The new session or chat is placed close to its source, and the receiving request includes a source link such as Sent by another session or Sent from another chat. Select the link to return to the exact session or chat that initiated it.

    Readable breadcrumbs for session files

    Files created in the internal session state directory previously showed internal session identifiers in editor breadcrumbs. Breadcrumbs now use stable provider and session labels, making it easier to identify the file location without exposing implementation details.

    Chat backgrounds in the Agents window (Experimental)

    Settings: chat.agentSessions.preferredDarkBackgroundImage, chat.agentSessions.preferredLightBackgroundImage, chat.agentSessions.backgroundImageLayout

    Personalize the Agents window with a decorative chat background: either a theme-aware pattern of built-in VS Code icons or an image of your own.
    Run Chat: Set Background... to choose between the Codicons pattern and an image from your machine. The five images you used most recently are offered under Recently Used, and that list is kept on this machine only.
    When you bring your own image, run Chat: Change Background Layout... to place it. Eleven layouts are available: Repeat, Stretch, Center, and each edge and corner. Moving through the list previews each layout in place, so you can judge the result before committing to it. Chat: Clear Background returns to the plain surface.
    Dark and light themes keep separate backgrounds. Every dark theme shares chat.agentSessions.preferredDarkBackgroundImage and every light theme shares chat.agentSessions.preferredLightBackgroundImage, so switching between a dark and a light theme swaps the background along with it. High contrast themes suppress backgrounds entirely, and the three commands are unavailable there.
    Chat content carries its own fill so that it stays readable over whatever sits behind it. Your request remains fully opaque, agent responses fade out through the padding on either side, and wide content such as Markdown tables and terminal output stays fully backed.
    Learn more about personalizing chat.

    Agent session notifications

    Settings: chat.notifyWindowOnConfirmation, chat.notifyWindowOnResponseReceived

    VS Code can notify you when an agent session needs your input or finishes its work. This is especially useful when you delegate work across multiple sessions, workspaces, or VS Code windows.
    By default, notifications only appear when the VS Code window is not focused. You can configure notifications separately for sessions that need input and sessions that have received a response. Notifications include a direct link back to the relevant session, so selecting one focuses the correct window and opens the session that needs attention.

    Agent Merge (Preview)

    Setting: chat.agentMerge.enabled

    Agent Merge helps you take a pull request across the finish line. It asks an agent to address review feedback, fix failed checks and merge conflicts, and rerun workflows. Agent Merge repeats this process until the pull request is ready to merge.
    To try Agent Merge, enable chat.agentMerge.enabled. You can currently enable Agent Merge for a session only from the Agents window. Run Enable Agent Merge for Active Session or select the Agent Merge button in the title bar. Learn more about using Agent Merge.

    Agent host

    The agent host lets you connect to the same agent session from multiple VS Code windows. It runs agent harnesses in a dedicated process based on the Agent Host Protocol (AHP). The agent host's Copilot agent is powered by the Copilot SDK, which aligns the agent's behavior and functionality with the Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.
    We're actively developing the agent host. The following screenshot shows the Copilot harness selected for an agent host in an editor window:
    Learn more in the agent host documentation and our new agent host blog post, where we share why we built the agent host, what it enables in VS Code, how the architecture and open protocol work, and workflows you can try yourself.
    If you have any feedback or requests, please let us know by filing an issue.

    Chat

    Enterprise controls for dictation data

    Administrators can manage the dictation model and language-model transcript cleanup through enterprise policies.
    The new controls make it possible to require on-device transcription and disable language-model cleanup, so dictation remains available while preventing dictation data from being sent to cloud transcription or a Copilot model. Learn more about enterprise controls for dictation data.

    Accessibility

    Screen Reader Optimized badge in the Agents window

    The Screen Reader Optimized badge in the Agents window title bar makes the active accessibility mode easier to identify. The badge appears when Screen Reader Optimized mode is enabled. Select the badge to disable this mode.

    Editor experience

    Layout density for the editor window (Experimental)

    Settings: workbench.experimental.modernUI, window.density.layout

    Fit more content in the editor window with the Compact layout density. When workbench.experimental.modernUI is enabled, you can choose between two layout densities:

    • Default layout density is the same as the current editor window layout.
    • Compact layout density removes the spacing between panels and reduces inner panel spacing.

    This setting is available in the Layout Density section of the Settings menu and can also be set using window.density.layout.

    Code editing

    Word wrapping improvements

    Injected text no longer pushes wrapped lines outside the editor viewport. Word wrapping takes the visual width of color decorators, inlay hint spacing, inline progress indicators, and breakpoint placeholders into account. Please have a look below for the before and after screenshots. On the picture above you can see that rgba is slightly cropped. While on the second picture it isn't.

    Integrated browser

    Spell check suggestions

    Right-click a misspelled word in an editable field to select a suggested correction. In sessions that use persistent data storage, you can also select Add to Dictionary.

    Terminal

    Reduced delay when running commands

    Terminal commands executed by extensions no longer incur an unnecessary delay when shell integration is ready under certain timing conditions. Users of the JavaScript debugger who hit this case will no longer experience a five-second delay when starting their programs.

    Deprecated features and settings

    None

    Thank you

    Contributions to vscode:

    • @abmahdy (Ahmed Mahdy): Bound concurrency of prompt file discovery reads PR #331855
    • @DanTup (Danny Tuppeny): Note that InlayHints with the same position are shown in-order PR #175525
    • @davidbitton (David B. Bitton): Add spelling suggestions to the Integrated Browser context menu PR #333043
    • @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #331727
    • @juliagongms (Julia Gong): nes: apply supportsUnifiedCompletions on the default provider path PR #332802
    • @koubaki: Update error message in inlineChatIntent.ts PR #329157
    • @ktsoator (ktsoator): Hover: restore scrolling for long content PR #331439
    • @na2co3-ftw (na2co3): Modern UI: Fix CSS specificity for tab action fading PR #332103
    • @preitinger (Peter Reitinger): Update snippet.md PR #231790
    • @remcohaszing (Remco Haszing):
      • Normalize end of line cursor move operation PR #296712
      • Fix out of bounds text selection with line wrapping PR #262910
      • Round custom line heights PR #298421
      • Expose the score function in Monaco editor PR #322959
    • @SimonSiefke (Simon Siefke):
      • fix: memory leak in explorer viewer PR #332332
      • fix: memory leak in LSP terminal completions PR #332173
    • @TheNotary: Update error message for unsupported skill attributes PR #328318
    • @tisilent (xiejialong): update label and description. PR #219949
    • @unsupportedpastels (Mark S.): Support reasoning effort in custom agent files PR #329263
    • @weidehai (io): error correction instructions PR #249715

    Contributions to vscode-emmet-helper:

    • @danfiedler-msft (Dan Fiedler): Pin GitHub Actions to full-length commit SHAs PR #108

    Contributions to vscode-livepreview:

    • @danfiedler-msft (Dan Fiedler): Pin GitHub Actions to full-length commit SHAs PR #854

    Contributions to docfind:

    • @danfiedler-msft (Dan Fiedler): Pin GitHub Actions to full-length commit SHAs PR #62

    Contributions to node-pty:

    • @danfiedler-msft (Dan Fiedler): Pin GitHub Actions to full-length commit SHAs PR #958

    Issue tracking

    Contributions to our issue tracking:

    • @gjsjohnmurray (John Murray)
    • @saroasid-web (Saswwo)
    • @zotabee (zotabee)
    • @lppedd (Edoardo Luppi)
    • @sandstrom (sandstrom)

    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
  • Aug 26, 2026
    • Date parsed from source:
      Aug 26, 2026
    • First seen by Releasebot:
      Aug 26, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.135

    Visual Studio Code releases 1.135 with a more streamlined Agents window, support for continuing Copilot or Claude agent sessions from other apps, an experimental Rubber Duck second-opinion feature, and detailed per-model chat usage tracking.

    Welcome to the 1.135 release of Visual Studio Code. This release helps you continue agent sessions across applications, get a second opinion on agent work, and understand chat usage while working in a more streamlined Agents window.

    • External agent sessions: Continue recent Copilot or Claude agent sessions from other applications in VS Code.
    • Rubber Duck (Experimental): Get a second opinion from a complementary model to surface missed details and edge cases.
    • Agents window UX improvements: Work with a streamlined side layout, simplified session controls, and session information that is easier to find.
    • Detailed chat usage: View a per-model breakdown of input, cached input, and output tokens for each chat turn.

    Happy Coding!

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

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

    Agents

    Agent host

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

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

    Learn more from our VS Code Agent Host documentation and the video below. If you have any feedback or requests, please let us know by filing an issue.

    See it in action in our Agent Host introduction YouTube video.

    Continue external agent sessions in VS Code

    Setting: chat.agentSessions.showExternal

    The Sessions list in VS Code can now show recent Copilot or Claude agent sessions that you created in other applications. By default, VS Code shows up to two recently updated external sessions. Select a session from the Sessions list to view the conversation and continue it in VS Code with your Copilot subscription.

    When you open an external session, a banner at the top of the chat lets you configure how many external sessions appear in the Sessions list. You can also use the External submenu in the Sessions list filter to choose which external sessions are shown. Change this preference at any time with the chat.agentSessions.showExternal setting.

    Rubber Duck (Experimental)

    Rubber Duck is an experimental feature that allows you to get a second opinion from a complementary model on the agent's work. It helps surface missed details or edge cases. You can use Rubber Duck by invoking the /rubber-duck command in a Copilot agent host session.

    Learn more about Rubber Duck in GitHub Copilot CLI.

    Single-pane side layout is now the default

    Setting: sessions.layout.singlePaneDetailPanel

    In the previous release, we introduced the single-pane layout. In this layout, session details and editors are located in a single side pane, with a shared tab bar next to chat. The single-pane layout is now enabled by default for the Agents window on desktop.

    This release also improves the layout:

    • Diffs use a side-by-side view when space permits and switch to an inline view when the side pane becomes too narrow. Use Always Show Inline Diff from the editor title menu to keep diffs inline at every width.
    • The action bar is less crowded. Editor-specific actions for diffs, view modes, code review, and attachments move to the editor title area, while the shared header focuses on showing or hiding Details.

    To use the classic layout, disable sessions.layout.singlePaneDetailPanel and reload the window.

    Simplified session controls and information

    The session header is less crowded, so you can identify the active session more easily and focus on the conversation.

    The session title has a prominent position, while an overflow menu next to the title groups actions for creating a chat and pinning the session. Search remains available in the Sessions list. When a session contains multiple chats, chat tabs replace the single-chat header.

    Session information moves directly above the chat input, where it is easier to find while you work. Pills can show changes, pull requests, issues, browsers the agent is interacting with, and artifacts from the session. For example, the Changes pill shows live file and diff counts and opens the complete set of session changes.

    Right-click an individual pill to open a context menu and choose which pill types are visible. The Changes pill remains visible whenever the session has changes.

    Chat

    Editor-style sticky scroll for chat (Experimental)

    Settings: chat.stickyScroll.enabled, chat.experimental.stickyScroll.enabled

    Chat sticky scroll lets you keep the current prompt visible as you scroll through and review long responses. We've further refined the behavior to make it more consistent with sticky scroll in the editor. Enable both settings to try the redesigned experience.

    View detailed chat turn usage

    To give you better insight into your chat usage, we've redesigned the chat response footer. When you hover over it, the footer shows a per-model breakdown of the input, cached input, and output tokens used in that chat turn.

    Sandboxing for the local agent harness

    We previously rolled out sandboxing to 50% of users to validate it on a larger scale and in real-world use cases. While we didn't identify a specific blocking issue, continuing the rollout would likely require more support and follow-up work at a time when we want to preserve focus on higher-priority investments, especially in the area of the agent host and the Copilot harness. We've therefore returned the default rollout to 0% for now.

    Sandboxing for the local agent harness remains available as an opt-in feature through the UI, so users who want to try it can still enable it.

    Deprecated features and settings

    None

    Thank you

    Contributions to vscode:

    • @a-stewart (Anthony Stewart): Rename leftover respectAutoSaveConfig variable to isRefactoring PR #160703
    • @bstee615 (Benjamin Steenhoek): Add eagerness option for diffpatch prompt PR #327544
    • @cipheraxat (Akshat Anand): fix: center Modern UI panel title tabs in the 32px header PR #331612
    • @danyalahmed1995 (Danyal Ahmed): Fix case-insensitive aggregated basename glob matching PR #316387
    • @dzsquared (Drew Skwiers-Koballa): add mcp server key as description in tool picker PR #325003
    • @guimmd2 (Guilherme Menezes Magalhães): Fix package.json hover metadata broken in npm 12+ PR #327951
    • @jachinsamuel (Jachin Samuel): docs: remove dead Gitter badge (service shut down June 2023) PR #322702
    • @jadefr (Jade Ferreira Vieira): Fix file URL to path conversion in html-language-features esbuild script PR #328557
    • @jainampatel27 (Jainam Patel): Fix typo in selectionHighlightMaxLength description PR #296427
    • @juliagongms (Julia Gong): nes: add optimized PatchBased02 prompt strategy PR #332018
    • @n-gist (n-gist): fix languages.getDiagnostics() problem-matchers diagnostics duplication PR #290278
    • @rfeltis (Ralph Feltis):
      • Remove Agents window startup A/A experiment trigger PR #331559
      • Revert chat quota trajectory nudge PR #331401
    • @RyanEwen (Ryan Ewen): Do not present a failed tool call as a successful one PR #330707
    • @SimonSiefke (Simon Siefke):
      • fix: memory leak in markersTable PR #327885
      • fix: memory leak in mainThreadDocumentsAndEditors PR #331170
      • fix: memory leak in settings preview indicator PR #331990
    • @srikanthananthula63053 (srikanthananthula):
      • fix: use fresh service accessor when lazily initializing chat attachment context (fixes #329610) PR #331416
      • Fix section checkbox state when all items are unchecked PR #331419
    • @TheRealAlexxx (alexxx): Fix typo in Settings UI description for editor.selectionHighlightMaxLength PR #332162
    • @zainnadeem786 (Zain Nadeem):
      • Await Workspace Trust transition completion in setUrisTrust() PR #328626
      • Fix PowerShell quoting for runInTerminal environment values PR #331753

    Contributions to vscode-windows-process-tree:

    • @danfiedler-msft (Dan Fiedler): Pin GitHub Actions to full-length commit SHAs PR #91

    Issue tracking

    Contributions to our issue tracking:

    • @gjsjohnmurray (John Murray)
    • @xguarch (Xavier Guarch)
    • @homeworld614 (homeworld614)
    • @johnnydecimal (Johnny Noble)
    • @wenma531 (noreply)

    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
  • Aug 19, 2026
    • Date parsed from source:
      Aug 19, 2026
    • First seen by Releasebot:
      Aug 19, 2026
    Microsoft logo

    Visual Studio Code by Microsoft

    Visual Studio Code 1.134

    Visual Studio Code releases a focused update that improves agent workflows with side-by-side chats, a prompt timeline, and Find in chat, while also making HTML preview easier by opening local HTML files in the integrated browser by default.

    Welcome to the 1.134 release of Visual Studio Code.

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

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

    Happy Coding!

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

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

    Agents

    Agent host

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

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

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

    Grid layout for chats in a session

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

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

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

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

    Improvements to the side pane layout

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

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

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

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

    Prompt timeline

    Setting: sessions.chatTimeline.display

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

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

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

    Chat

    Find in chat

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

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

    Editor Experience

    Close other editors from a tab

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

    Open HTML files in the integrated browser by default

    Setting: workbench.editorAssociations

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

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

    Thank you

    Contributions to vscode:

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

    Issue tracking

    Contributions to our issue tracking:

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

    We appreciate people trying our new features as soon as they are ready. Check back often to learn what's new.

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

    Original source
Releasebot

Curated by the Releasebot team

Releasebot is an aggregator of official product update announcements from hundreds of software vendors and thousands of sources.

Our editorial process involves the manual review and audit of release notes procured with the help of automated systems.