Category: Visual Studio

January 26, 2026 by Harald Kirschner and Connor Peet

AI coding agents have become remarkably capable. Out of the box, they search your codebase, edit files, run terminal commands, and respond to compile errors. Add MCP servers, and they can query databases, browse the web with Playwright, summarize GitHub issues, and connect to your cloud platforms. Models can even process images—you can paste a screenshot to debug a layout issue, or have Playwright capture browser state for verification.

Agents format tables, structure data, and render ASCII diagrams. But none of this is interactive. When you need to reorder a list, confirm a destructive action with specifics, or explore a visualization, you’re back to describing things in sentences.

Today, the MCP community is announcing MCP Apps, the first official MCP extension. Tool calls can now return interactive UI components that render directly in the conversation: dashboards, forms, visualizations, multi-step workflows. This creates opportunities for a richer and more effective human-agent collaboration.

VS Code is the first major AI code editor with full MCP Apps support. Available now in VS Code Insiders—our daily build where new features land first. Install Insiders to try MCP Apps today, and expect this to roll out to VS Code Stable in next week’s release.

Demos: Where Interaction Beats Text

We’ve built a few demos to show where agents benefit from richer collaboration with developers. Since MCP Apps is new, we look forward to seeing more adoption across the ecosystem.

Interactive List Reordering

Today: Agent proposes a sorted order based on its analysis. You read the text output, request adjustments, and go back and forth until the order matches your preferences.

With MCP Apps: Agent displays a drag-and-drop interface alongside its suggested order. You reorder items visually, or select “Ask AI to Sort” to let the agent apply its reasoning.

Performance Profiler Visualization

Today: Agent analyzes CPU profile data and summarizes bottlenecks in text. You see the summary but have no way to validate the hypotheses or explore areas the agent might have overlooked.

With MCP Apps: Agent renders an interactive flame graph. You drill into call stacks, hover for timing details, and confirm or reject the agent’s analysis with your own domain knowledge.

Feature Flag Selector

Today: Agent fetches flag configuration and lists what exists. You cross-reference mentally with your deployment context and ask the agent to generate integration code in a separate step.

With MCP Apps: Agent displays a searchable flag picker with live environment status. You select flags, switch between prod/staging/dev views, and generate SDK code—all in one interaction.

Partner Spotlight: Storybook

Storybook has added MCP Apps support to their open source MCP server. Simply ask an agent to “build a login form using our design system” instead of describing the desired result in extensive detail, and the agent renders an interactive component preview directly in VS Code.

“We’ve been working with the VS Code team on MCP Apps and we’re excited about the results. Users can now preview Storybook stories directly in the agent chat, eliminating the need to navigate between the chat and their Storybook to review changes.” – Jeppe Reinhold (Storybook core contributor, Chromatic)

A Natural Fit for VS Code

VS Code has always been more than a text editor. Extensions bring UI and interaction into the editor through webview panels, custom editors, and sidebar views. Jupyter notebooks showed that mixing code with rich output transforms workflows. GitHub Copilot agents gave AI the ability to work autonomously in your workspace.

MCP Apps is the next layer: giving agents a visual voice to communicate back. You see what’s happening, make choices with confidence, and stay in control.

Get Started

If you’re building MCP servers, add MCP Apps to make them more interactive. VS Code is where you can develop and debug them with full MCP support. Join today’s VS Code livestream with Den Delimarsky, MCP core maintainer, for live demos and Q&A.

Try building your first MCP App and share what you create with the community. Sometimes showing is better than telling—now your agents can do both.

Happy Coding! 💙

I have configured my computer for remote debugging: I have the Visual Studio solution and projects on my development computer and the testing is about to happen on a remote testmachine.

On the testmachine, the entire installation procedure has been executed, and everything is working fine. The remote debugger is launched, the options mention no authentication being needed, allowing any user to debug. This is working fine.
On the development machine, I’ve prepared everything for remote debugging, and indeed, starting the application on the remote machine is working fine, as can be retrieved from the following screenshot:

I can confirm that the mentioned process ID (11176) is indeed the PID of the corresponding process on the remote testmachine.
On the development machine, there is no process with that process ID.

The following line is giving an access violation:

ILicPtr lic = ILicPtr(CLSID_Lic);

That pointer is defined in a *.tlh file, as follows: _COM_SMARTPTR_TYPEDEF(ILic, __uuidof(ILic));

The value of CLSID_Lic equals {07BA438E-D124-4A78-892F-125B0FC5A98A} and is found in the registry of the testmachine, at following locations in registry:

HKEY_CLASSES_ROOT\Company.License.BusinessRules.Lic\CLSID => Default
HKEY_CLASSES_ROOT\Wow6432Node\CLSID\{07BA438E-D124-4A78-892F-125B0FC5A98A}
Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Company.License.BusinessRules.Lic\CLSID => Default
Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Classes\WOW6432Node\CLSID\{07BA438E-D124-4A78-892F-125B0FC5A98A}
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Classes\CLSID\{07BA438E-D124-4A78-892F-125B0FC5A98A}

For your information: if I try to run the application on the testmachine without debugging, everything works fine.

What’s wrong with that line and how can I get over this?

February 5, 2026 by VS Code Team, @code

Agents are everywhere. We’ve been working to make VS Code the home for multi-agent development. One place to run your agents, manage your sessions, and pick the right tool for each task, without switching editors or juggling subscriptions.

With the January 2026 release (1.109), we’re taking the biggest step forward since we laid out that vision at GitHub Universe last year. You can now run Claude and Codex agents directly alongside GitHub Copilot. Start them as local agents when you need fast, interactive help, or delegate async to a cloud agent for longer-running tasks. We’ve also made updates to the Agent Sessions view, your single place to manage your agents.

Manage all your agents

The agent landscape keeps moving fast. We’re all still figuring out how to work with agents. Fire-and-forget when the task is clear, hands-on when you want control, or somewhere in between; it depends on the task, and it changes. Either way, more agents mean more sessions to keep track of.

The Agent Sessions view gives you one place to see all your agent sessions—local, background, cloud—and move between them as you work.

Kick off a cloud agent for a well-defined refactor, then jump into a local session for something more exploratory. Monitor a background task or let it run as you work on something else.

The above demo illustrates how developers are constantly tackling multiple things at once: planning improvements, building features, reviewing results, debugging errors. For each moment, you need to pick the right tool: local when needing to steer, background or cloud when wanting isolated changes, parallel subagents when needing multiple processes.

Here’s a quick overview to help you decide when to use local, background, or cloud agents:

Criteria	Local	Background	Cloud
Where it runs	Your machine	Your machine (CLI)	Remote infrastructure
Interaction style	Interactive	Unattended (async)	Unattended (async), Autonomous
Team visibility	No	No	Yes (PRs/issues)
Isolation	No (direct workspace)	Yes (worktrees)	Yes (remote)

Now that you can run multiple agent types, the next question is which agents to use.

Your agent, your choice

With 1.109, you can run Claude and Codex agents: locally, or in the cloud, all under your same GitHub Copilot subscription.

Codex has been available as a local agent for a few months. Claude is new. It uses the official Claude Agent harness by Anthropic, so you get the same prompts, tools, and overall architecture as other Claude implementations.

GitHub also just announced Claude and Codex agent support. Copilot Pro+ and Enterprise subscribers can use them in VS Code as cloud agents today.

The beauty of this unified approach is that all these agents show up in the same Agent Sessions view. You can delegate tasks between them, compare their outputs, and pick the right tool for each job.

Orchestrate with subagents

Running multiple agents is one thing. Getting them to work together is another.

Let’s say you’re adding a new feature and your agent needs to research authentication patterns, check how similar features are structured in your codebase, AND scan the relevant docs. Doing this sequentially eats up time and adds a lot of context that makes it hard for the agent to focus on what’s important.

Subagents solve this. They’re context-isolated agents that run independently from your main session—your main agent delegates work and only the final result flows back. The intermediate exploration stays contained, keeping your primary context clean.

What’s new this release: VS Code can now run multiple subagents in parallel. Fire off multiple tasks at once, get results faster, and save premium requests in the process.

We’ve also added better visibility into what subagents are doing. You can see which tasks are running, which agent is being used, and expand any subagent to see the full prompt and result.

Combine this with custom agents to give each subagent specialized behavior: a research agent with read-only access and web search tools, an implementation agent with full editing capabilities, a security agent focused on vulnerability scanning. Define the tools, instructions, and model for each. Use handoffs to create workflows that transition from plan to implement to review—all orchestrated from your main session.

Building on open standards

More agents, more ways to use them. But agents are only as useful as you can make them for your workflow.

That’s where open standards come in.

MCP Apps landed last week. This is the first official MCP extension, and it lets tool calls return interactive UI components that render directly in chat: dashboards, forms, visualizations, multi-step workflows. This creates opportunities for a richer and more effective human-agent collaboration. VS Code is the first major AI code editor with full MCP Apps support, and we’re so excited to see what the community builds.

We’ve also made Agent Skills, Anthropic’s open standard for extending AI agents, generally available. Skills are specialized capabilities that help agents produce high-quality outputs—they provide tested instructions for domains like testing strategies, API design, or performance optimization. Extension authors can now even package and distribute skills with their extensions using the chatSkills contribution point. This means the ecosystem can share specialized AI capabilities the same way it shares code snippets and themes.

VS Code: your unified agent experience

Agents are changing how we work. You shouldn’t have to pick just one, or switch tools every time something new comes along. With VS Code, you can run the agents you want, extend them with open standards, and manage it all from one place.

A year ago, we were just introducing agent mode. Now you’ve got Copilot, Claude, and Codex running side by side and SO much more. We’re building this alongside you, and your feedback shapes what comes next. Drop us an issue in the VS Code repo or find us on social. We’re just getting started.

Want to see these features demoed live? Join us for Agent Sessions Day on February 19th!

Happy coding!

I am following the example from the book professional cpp 5ed, ch9.
I have a .ixx file with a member swap function taking 1 argument, and a non-member function taking 2.

export module Spreadsheet;
export import SpreadsheetCell;

export class Spreadsheet
{
public:
    Spreadsheet(size_t width, size_t height);
    Spreadsheet(const Spreadsheet& src);
    Spreadsheet(Spreadsheet&& src) noexcept; 
    ~Spreadsheet();

    Spreadsheet& operator=(const Spreadsheet& rhs);
    Spreadsheet& operator=(Spreadsheet&& rhs) noexcept; 

    void setCellAt(size_t x, size_t y, const SpreadsheetCell& cell);
    SpreadsheetCell& getCellAt(size_t x, size_t y);

    void swap(Spreadsheet& other) noexcept;

private:
    void verifyCoordinate(size_t x, size_t y) const;

    size_t m_width{ 0 };
    size_t m_height{ 0 };
    SpreadsheetCell** m_cells{ nullptr };
};

export void swap(Spreadsheet& first, Spreadsheet& second) noexcept;

Here are their implementations in the .cpp file:

void Spreadsheet::swap(Spreadsheet& other) noexcept
{
    std::swap(m_width, other.m_width);
    std::swap(m_height, other.m_height);
    std::swap(m_cells, other.m_cells);
}

void swap(Spreadsheet& first, Spreadsheet& second) noexcept
{
    first.swap(second);
}

The book recommends implementing move constructor and move assign through swap, like so:

// Move constructor
Spreadsheet::Spreadsheet(Spreadsheet&& src) noexcept
{
    cout << "Move constructor" << endl;

    swap(*this, src);
}

// Move assignment operator
Spreadsheet& Spreadsheet::operator=(Spreadsheet&& rhs) noexcept
{
    cout << "Move assignment operator" << endl;

    swap(*this, rhs);
    return *this;
}

However, my visual studio doesn’t see the exported non-member function swap that takes 2 parameters. It gives me E0140 too many arguments in function call, C2660 'Spreadsheet::swap' function does not take 2 arguments, and the intellisense overload list for swap is empty.

error in visual studio

So my questions are:

1. is it a bug in visual studio, or am i blind and missing something? I thought the exported non-member would be treated like a regular overloaded function, and i can’t understand why compiler is not seeing it.

2. Why are we using the non-member function for it in the first place? Omitting it and using swap(rhs); instead of swap(*this, rhs); seems to work, so why would it be recommended to do it the other way?

Im using VS2022(v143), c++ standard set to latest features

Last updated: February 5, 2026

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

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

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

Happy Coding!

---

February 5, 2026

• Add setting to control the scroll behavior in the Settings editor, offering continuous or paginated. Paginated will restrict the settings shown to only those in that category. #291391

February 4, 2026

• Improved chat askQuestion carousel now has improved accessibility. ARIA labels have been added, keyboard focus can be moved to the container, and focus no longer automatically moves to the first response. A new command and keybinding is available to focus the first response in screen reader mode. #292917

• Add support for the text blink attribute in the integrated terminal. #292550

• Add support for color scheme reporting in the integrated terminal, allowing programs to query the terminal’s current color palette. #290919

• Populate the Find control input in the integrated browser’s with the currently selected text on the page, matching standard browser behavior. #291378

• Show download progress information when downloading a VS Code update. #277330

February 3, 2026

• Terminal performance has been improved with updates to xterm.js, including optimizations for rendering and processing. #292572

• Respect session list filters in the agent sessions Quick Pick and welcome page. If you have specific agent types filtered out from the session list, they will also be excluded from the Quick Pick when switching sessions. #291603

February 2, 2026

• Improved screen reader accessibility for quick input dialogs. ARIA attributes are now dynamically set only when the list is active, preventing redundant announcements. The Go to Line dialog (Ctrl+G) now provides proper screen reader announcements for characters typed and list item navigation. #292353

• Selecting Hidden terminal in the terminal dropdown now directly opens the terminal when there is only one hidden terminal, instead of showing a quick pick menu. #291884

• Fixed an issue where the terminal output panel in chat would auto-collapse on command success even when manually expanded. The panel now respects the user’s manual expand state and remains expanded after successful command completion. #291120

January 30, 2026

• The chat question carousel UI now uses a list-style selection interface similar to QuickPick instead of native radio buttons and checkboxes. This provides better visual consistency with other VS Code selection UIs across platforms. #291328

---

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

I am attempting to create a Rest API Client from the Swagger json file generated by Ambari. Unfortunately the json uses # in item names:

  "get": {
    "tags": [ "Actions" ],
    "summary": "Get all action definitions",
    "description": "",
    "operationId": "ActionService#getActionDefinitions",       <<<<<
    "produces": [ "text/plain" ],

I have tried AutoRest, Nswag, Swagger and Open API Rest API Client Generators.
Nswag is the only one that does not crash and burn.
However it’s output is unusable because the ‘#’ characters end up in the c# names.

I end up with lines like…unusable:

System.Threading.Tasks.Task<System.Collections.Generic.ICollection<ActionResponseSwagger>> ActionService#getActionDefinitionsAsync(string fields, string sortBy, int? page_size, string from, string to);

Is there a work around to this issue ?

I am having trouble getting Asan to pick up on heap memory not being freed.

---

int main() {

    int* arr = new int[10];
    // arr[10] = 5; // Asan will warn me about this invalid access

    // Asan says nothing about the arr I did NOT free
}

---

I have configured Asan for Visual Studio 2022 as described here: https://learn.microsoft.com/en-us/cpp/sanitizers/asan?view=msvc-170#ide-msbuild

I have tried both the Visual Studio UI version of running Asan by running the debugger and the command line version of build the executable and then running it. Neither mention the memory not being freed.

---

Is it not possible ot get Asan to warn about a memory leak like this?

I’m working on a Visual Studio Extension that creates a popup WPF Window, the window does have a TextBox in which can be input text.

The problem I’m facing is: Whenever I have the TextBox focused and send Backspace/Ctrl + A or Esc to it, the keystrokes goes to whatever document window I had active before instead of the TextBox.

In the gif: I have the TextBox focused it recognize normal keystrokes like a-z, but when i send Ctrl+A to it, it goes to the document window in the background, same thing for Backspace, it erases things in the document instead of the TextBox which is active.

I have created a minimal reproducible example, the code can be found here:
https://github.com/jinjiere/VSExtension

A similar issue related to these keystrokes:
https://developercommunity.visualstudio.com/t/Issue-where-backspace-ctrlz-and-other/11023655?ref=native&refTime=1769989905247&refUserId=67e5f4a0-c9fb-6b2b-9ad6-7f2145a23b45

I’m not sure if its a VS bug, I have also report it here: https://developercommunity.visualstudio.com/t/Custom-WPF-Window-ignore-specific-keystr/11037258