Category: Visual Studio

August 26, 2026 by Rob Lourens, Connor Peet, and Brigit Murtaugh

When you assign work to an agent, it should just continue its work, even when you’re not actively watching. Whether you switch to another agent session, move between the editor and the Agents window, or connect remotely from another machine or the browser, you should be able to monitor and interact with that session.

We’re introducing the Agent Host, a self-contained process that owns agent sessions, and the open Agent Host Protocol (AHP) for connecting hosts and clients. Together, they enable sessions to continue after you close the folder or editor window where they started, stay synchronized across clients, run locally or remotely, and support multiple agent harnesses without losing their distinct capabilities.

In this post, we’ll explain why we built the Agent Host, what it enables in VS Code (and how you can try it), how its architecture works, and how AHP opens that architecture to other clients.

Why we built the Agent Host

In late 2025, we added support for closing a local agent chat and keeping it running in the background. That made it possible to run multiple sessions in parallel or focus on another task while you were in VS Code. The next step was enabling those sessions to continue after you closed the folder where they started and to move across VS Code surfaces.

Aside from supporting long-running sessions, we set out to adopt the GitHub Copilot SDK for the Copilot harness in VS Code. Using the SDK gives Copilot a more consistent harness behavior and functionality across Copilot CLI, the standalone GitHub Copilot app, and other Copilot products.

Bringing these efforts together gave us an opportunity to reevaluate how we run agent harnesses in VS Code. An agent harness assembles context, provides tools, runs the agent loop, and applies changes. Without the Agent Host, VS Code runs the local agent harness in each editor window’s extension host, the process that VS Code uses to run extensions such as GitHub Copilot Chat. The extension host isolates extension code from the core editor, however it also ties the agent runtime to one VS Code window. Closing that window stops the runtime. As a result, each window loads its own agent infrastructure.

Moving session state, harness adapters, and baseline workspace capabilities into a dedicated process changes that boundary. The extension host is no longer in the critical path for baseline agent work, and multiple windows can connect to one host instead of each loading a separate runtime. VS Code still communicates with the host, and tools contributed by a client still route back to that client, but the session itself no longer depends on the specific folder or editor window where it started.

This separation also gives VS Code a common foundation for multiple agent harnesses while preserving what makes each one distinct. Earlier this year, we introduced the Claude Agent using Anthropic’s official harness. Copilot and Claude can retain their own SDKs, agent loops, tools, and provider-specific capabilities, while the Agent Host and AHP give them a consistent session experience in VS Code.

What the Agent Host enables

The Agent Host is enabled in the latest VS Code Stable and Insiders. Because the Agent Host owns the session, you can start working with an agent in an editor window and continue with the same live session in the Agents window. Both surfaces stay synchronized, so you can monitor progress and interact with the session wherever you prefer without creating a copy.

The separation between clients and hosts also enables remote sessions. The Agent Host can run with your workspace on another machine while you connect from the desktop or web to check progress, review changes, and manage sessions. Learn more about remote agent sessions, including setup instructions for SSH, dev tunnels, and the web.

Try this workflow to experience how a session continues after you close its folder and stays in sync across VS Code surfaces:

1. Open a folder in an editor window, select Copilot from the harness picker, and start an agent session as you normally would.

   

2. While the agent is working, close the folder but keep VS Code running. The active turn continues in the Agent Host even though that folder is no longer open.

   Note: Closing a folder does not quit VS Code. For local sessions, VS Code must remain running because it manages the local Agent Host.

3. Reopen the folder and return to the session. Its state and progress are still there.

4. Open the Agents window to monitor the same live session. You can work with it from the editor and Agents window without creating a copy, and updates appear in both.

5. To try a remote connection, connect the Agents window to a remote Agent Host and start or open a session. Then open insiders.vscode.dev/agents, select the same host, and continue the session from your browser.

   

How the pieces fit

The Agent Host is a dedicated process that owns sessions. It can run locally as a VS Code utility process or remotely as a standalone server. In either case, it remains active across many editor sessions. Previously, we could rely on direct IPC between the extension host and editor window, but a persistent process that could communicate with multiple versions of VS Code necessitates a standardization in how we talk about agents. The Agent Host Protocol (AHP) is that standardization.

When the host runs on the same machine as VS Code, all editor windows and the Agents window connect to the single host process. In AHP terms, those windows are clients and the Agent Host plays the server role. VS Code bundles our own implementation of an Agent Host and our UI is a client, but other applications can implement either side of the same agnostic protocol. Clients can also contribute tools based on their own capabilities.

The Agent Host is designed to support different harnesses. Each harness retains its own agent loop and capabilities, while an adapter translates its events into the common AHP session model. Here are two examples of how this works:

• The Copilot harness is powered by the GitHub Copilot SDK, which manages its runtime as a child process.
• The Claude harness loads Anthropic’s Claude Agent SDK. Its adapter maps sessions, tools, permissions, and subagents into AHP while retaining features such as slash commands and hooks.

AHP standardizes the client-facing session, not how an agent reasons, manages context, or calls tools. Learn more about choosing an agent harness in VS Code.

Why an open protocol?

Most agent protocols describe a one-to-one conversation between a client and an agent. AHP solves a different problem: coordinating multiple independent clients around the same long-running agent session. The host owns the authoritative, agent-agnostic state, while connected clients can observe progress, contribute actions, approve tool calls, or cancel work.

AHP is deliberately state-first. Rather than expose harness-specific backend events, the host translates them into durable, display-ready state and ordered Redux-like actions. Clients can optimistically apply an action and reconcile it with the host’s sequenced response, then replay missed actions gracefully on reconnection.

The state is opinionated to reflect which user experience clients should present, and it avoids going into implementation details. For example, while our Agent Host drives changes through local git and GitHub, this is modeled as the generic concept of changesets. Implementations can operate on other representations – for example, in-memory virtual file systems like those used on vscode.dev or by the GitHub Repositories extension.

All protocol functionality is exposed as URI-addressable channels, including sessions, chats, terminals, and changesets. When a client subscribes, it receives a snapshot of the current state followed by an ordered stream of actions. Shared reducers apply those actions consistently, so an editor, the Agents window, and a browser client converge on the same view without each client having to understand the harness’s SDK or session model.

While AHP handles these coordination challenges, we also want it to be straightforward to implement. At the coarsest level, clients and hosts choose which channels they implement beyond the basic session and chat channels, and negotiate capabilities for finer-grained control. As we add functionality, it will continue to compose into the protocol – providing richer experiences for setups that expose it without adding burden for new clients and hosts.

Build your own AHP client

Because AHP is open, you can build clients that connect to an Agent Host to monitor session progress, review changes, approve tool calls, and contribute tools based on the client’s capabilities.

To get started, run code agent host (or code-insiders agent host for Insiders) to start a standalone Agent Host on your machine. Then connect to it with one of the AHP client libraries:

See the AHP client library table for current versions and additional clients.

Follow along and share feedback

VS Code’s Agent Host implementation and the AHP specification are under active development, and new capabilities continue to roll out. Follow the Agent Host architecture documentation for current VS Code behavior. To follow AHP’s design or share feedback on the protocol overall, explore the AHP documentation and source repository.

As you run agents through the Agent Host in VS Code, please share your feedback with us in the VS Code repository.

Happy coding! 💙

Follow us on LinkedIn, X, Bluesky | Follow Insiders Changelog on X or Bluesky

Last updated: August 11, 2026

Welcome to the 1.134 Insiders release of Visual Studio Code.

These release notes cover the Insiders build of VS Code and continue to evolve as new features are added.

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

Happy Coding!

August 11, 2026

• Hide the Voice Mode listening or barge-in placeholder in the chat input while you’re typing, and restore it once the input is cleared. #330288

• Add a link to configure voice.md instructions to the Voice Mode onboarding banner, alongside the existing settings link. #328083

• Fixed an issue where Voice Mode instructions in voice.md were not applied. #328860

August 10, 2026

• Add support for associating HTML files with the integrated browser using the
  
  
  workbench.editor.associations

  
  
  
  

  setting, so they open directly in the browser instead of the text editor. #328545

• Add subtitles and status indicators to the Chats picker in the Agents window, grouping regular, forked, and side chats separately from active subagents. #329176

• Add support for selecting the unsaved editors count badge in the Open Editors view to jump to the first unsaved editor. #328907

• Add a keybinding to reopen the most recently closed chat or session, mirroring how browsers reopen a closed tab. #329184

August 7, 2026

• Add support for running Codex sessions in the agent host with an OpenAI, ChatGPT, or other configured model provider without requiring GitHub Copilot sign-in. #329668

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’ve been looking for a practical way to build Azure skills, Cloud Academy (a QA company) gives Visual Studio subscribers hands-on learning that fits into busy schedules. 

Whether you’re new to Azure, expanding your cloud expertise, working towards certifications or preparing for more advanced projects, this benefit helps you learn by doing. 

What you’ll find in Cloud Academy 

The Cloud Academy benefit gives Visual Studio subscribers a flexible learning experience that adapts to different learning styles and schedules, providing: 

• Hands-on Azure labs that reinforce real-world skills 

• Certification-focused learning paths 

• Interactive assessments to validate your understanding 

• Structured learning paths alongside open sandbox environments for experimentation 

• AI-powered on-demand guidance and assistance 

With the Cloud Academy benefit, you’re not just consuming content. You’re practicing in environments that help prepare you for the work you’ll be doing every day. 

Prepare for Azure certifications 

If certification is one of your goals, Cloud Academy brings together lessons, hands-on labs, and assessments into a single learning experience. 

One example is the AZ-104 Exam Preparation: Microsoft Azure Administrator course. It’s specifically designed to help you prepare for the AZ-104 Microsoft Azure Administrator certification exam while strengthening the practical Azure administration skills you’ll use on the job. 

Learning resources available through Cloud Academy that will ready you for Azure certifications include: 

• AI-900: Microsoft Azure AI Fundamentals 

• AZ-104: Microsoft Azure Administrator  

• AZ-400: Designing and Implementing Microsoft DevOps Solutions 

• AZ-305: Designing Microsoft Azure Infrastructure Solutions 

By combining guided instruction with hands-on practice, you can build both the knowledge and confidence to apply these skills in production environments. 

Cloud Academy can also help you focus on real-world Azure scenarios that build skills you can apply immediately. Examples include containerized application deployment and management, Azure Functions and workflow automation, Azure Container Registry, storage cost optimization, Microsoft Entra ID security improvements, Azure AI, prompt engineering, and more. 

As Azure continues to evolve, Cloud Academy helps you stay current while building confidence that carries over to real projects. Whether you’re exploring Azure AI, building cloud-native applications, improving your DevOps skills, or preparing for your next certification, you can make steady progress without stepping away from your day-to-day responsibilities. 

Activate your benefit today 

If you’re an eligible Visual Studio subscriber, don’t overlook this valuable learning resource already included with your Visual Studio Subscription. 

Visit the Visual Studio Subscriptions portal to access your Visual Studio Subscription benefits and activate your Cloud Academy benefit today. 

July 29, 2026 by Faith Xu

In VS Code, we’re working to help you get more done with AI-assisted coding while making every token count. That means improving the entire experience, from the models we use to the product and infrastructure behind them, so you have options that fit different workflows, performance needs, and budgets.
In The Coding Harness Behind GitHub Copilot in VS Code, we explained how VS Code’s coding harness connects the model, tools, and editor experience to help the model work most effectively.

In this post, we look at how specifically training models for VS Code’s harness can further improve quality and efficiency. The model we focus on is MAI-Code-1-Flash, Microsoft’s lightweight coding model built for the fast, iterative coding tasks developers perform every day in GitHub Copilot. Since the model’s introduction at Build, it has been running in production alongside leading coding models, giving us an early look at how it performs in real developer workflows.

The results show that pairing MAI-Code-1-Flash with the VS Code coding harness delivers strong coding quality with lower token usage, helping developers get more from their usage limits.

Quality and efficiency in production

When evaluating coding models, quality and efficiency matter. A model that uses fewer tokens lowers cost, but those savings are more valuable if developers can still accomplish their tasks effectively. The goal is to strike the right balance: strong coding quality while using tokens efficiently.

To understand how MAI-Code-1-Flash performs in that tradeoff, we analyzed aggregate data from developers who selected each model in VS Code Copilot Chat. We looked at both the quality of the generated code and how efficiently developers reached a durable result. For quality, we measured whether developers accepted generated suggestions and whether that code remained after active editing and at commit. For efficiency, we measured the median number of tokens generated per conversation turn and the median number of turns needed to reach a commit.

The results suggest that MAI-Code-1-Flash strikes an effective balance between quality and efficiency. It outperforms Claude Haiku 4.5 and GPT-5.4 Mini on quality. Larger-sized GPT-5.6 Luna and Kimi K2.7 Code achieve quality advantages, but require 67% to 94% more tokens per turn as well as more turns per commit.

Data from users who selected each model in VS Code Copilot Chat between 6/2/26 and 7/24/26.
Metric definitions: Code survival rate = percentage of AI-generated code retained after 10 minutes of active editing. Commit survival rate = percentage of AI-generated code retained at Git commit. Accept rate = percentage of AI-generated suggestions accepted by the user. Tokens per turn = median number of tokens generated by the model per conversation turn (a single request-response exchange). Turns per commit = median number of conversation turns a user completes before reaching a Git commit.

Validating the results with Auto flights

As another way to validate the aggregated usage data, we ran A/B flights through the Auto model experience in VS Code Copilot Chat. Auto assigns models without requiring developers to select one, helping us isolate the model’s impact from differences in who chooses each model or the tasks they use it for. We then looked at engagement and repeat usage as signals of whether developers found the experience useful enough to keep using.

The results reinforced the same story. MAI-Code-1-Flash drove stronger engagement while remaining more token efficient than other lightweight models. Users were 6% more likely to return within two days than with GPT-5.4 Mini and 11% more likely than with Claude Haiku 4.5. Despite higher engagement, median token usage was 13% lower than GPT-5.4 Mini and 11% lower than Claude Haiku 4.5. In other words, people used MAI-Code-1-Flash more, and it still cost less to run.

Taken together, the production metrics and Auto flights highlight the role MAI-Code-1-Flash is designed to play: delivering strong results on simple coding tasks while using tokens efficiently. To close, let’s take a closer look at the model and the workflows it was built to support.

Designed for the way developers work

MAI-Code-1-Flash was developed to work closely with the VS Code coding harness and the real-world workflows it supports. It’s particularly well-suited for lightweight, iterative work such as exploring code, making incremental changes, generating or refining tests, and fixing bugs. Its adaptive solution length keeps responses concise for simple requests and goes deeper only when needed. This means it delivers useful output faster, while also improving token efficiency.

The model was trained from scratch using clean, traceable data, without distillation from third-party models. The model will continue to improve over time based on aggregated usage signals from consumer plans, while Copilot Business and Copilot Enterprise customer data is not used for training.

Try it today, help shape what’s next

MAI-Code-1-Flash is available today in GitHub Copilot. Try it alongside your current go-to model, see how it feels in your workflow, and share what works well or what you’d like to see improve in the Community Discussion, where the team is actively listening.

Your feedback also helps shape what’s next. MAI-Code-1-Flash is just the first step in the MAI coding model journey. Larger MAI coding models coming later this year will extend the family to more complex tasks, with greater intelligence, deeper reasoning, and quality designed to compete with the strongest frontier models.

Happy coding! 💙

Follow us on LinkedIn, X, Bluesky | Follow Insiders Changelog on X or Bluesky

Last updated: July 29, 2026

Welcome to the 1.132 Insiders release of Visual Studio Code.

These release notes cover the Insiders build of VS Code and continue to evolve as new features are added.

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

Happy Coding!

July 29, 2026

• Add support for showing ~ instead of the full home directory path in terminal tab titles that use the ${cwd} variable, reducing visual noise for paths nested under your home directory. #274200
• Add support for the --enable-proposed-api flag when running code serve-web, so extensions that declare enabledApiProposals in their package.json activate correctly in the browser, matching the existing desktop behavior. #228781
• Add support for removing only the innermost manual folding range at the cursor position with the Remove Manual Folding Ranges command, instead of removing every manual range that intersects the cursor. #212599

July 28, 2026

• Add support for customizing Dictation and Voice Mode with dictation.md and voice.md files, stored in your user profile (~/.copilot/dictation.md, ~/.copilot/voice.md) or in a trusted workspace’s .github folder. #327334
• Add support for copying code blocks in the Markdown preview with a hover-triggered copy button on each fenced code block. #322269

July 27, 2026

• Add support for combining multiple attachments of the same browser element into a single item, including both its text content and screenshot. #327733
• Add Save and Save As to the editor tab context menu, so you can save a dirty file directly from its tab without opening the Explorer or File menu. #327504

July 24, 2026

• Fix an issue where canceling dictation while the speech-to-text model was still downloading or loading had no effect, leaving you stuck waiting for the download to finish. #327292

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

Organizations are increasingly looking for greater control over extensions within development environments. Driven by security, compliance, and internal governance requirements, teams want more visibility into how developers discover and acquire extensions.

To address these needs, we’re excited to begin previewing Private Marketplace support in Visual Studio.

Private Marketplace for Visual Studio