Microsoft's Agent Host Protocol Makes Coding Sessions Portable

Microsoft has moved an important piece of AI coding infrastructure out of the editor window and into a dedicated process. In its August 26 announcement, the Visual Studio Code team introduced the Agent Host and the open Agent Host Protocol, or AHP.

The change sounds like plumbing. It is actually a bet on a different ownership model for software agents: the editor becomes a client, while the long-running session belongs to a host that can survive window changes, support multiple harnesses, and run locally or remotely.

The session is no longer owned by the editor window

The old model tied a local coding agent to the extension host inside a particular VS Code window. Close the folder or window and the runtime stopped with it. Each new window also loaded another copy of the agent infrastructure.

The Agent Host changes that boundary. It owns the session, its state, baseline workspace capabilities, and the adapter that connects the session to a particular agent harness. Multiple VS Code surfaces can connect to the same live session, while the work continues even when the developer is not actively watching it.

That matters because agent work is increasingly asynchronous. A coding task may begin in a terminal, continue in an editor for review, and then be monitored from a browser or another machine. Reconstructing context at each handoff wastes tokens and introduces opportunities for the developer or the model to lose the thread.

AHP is designed around a durable state model rather than a stream of provider-specific events. Clients receive a snapshot and an ordered sequence of state changes. That gives each connected surface a common way to catch up, reconcile updates, and reconnect without having to understand the internals of Copilot, Claude, or another harness.

A protocol for clients, hosts, and harnesses

Microsoft describes AHP as an open, agent-agnostic protocol for connecting hosts and clients. The host can run as a VS Code utility process or as a standalone remote server. The client can be an editor window, the Agents window, or a browser connection through remote development infrastructure.

The distinction between a host and a harness is important. The harness still controls the agent loop, context management, tool use, and provider-specific features. The host provides the lifecycle and session surface around it. In the current design, Copilot uses the GitHub Copilot SDK, while the Claude harness uses Anthropic’s Claude Agent SDK. Adapters translate those runtimes into the shared AHP session model without flattening their differences.

This is the same strategic pattern that made the Language Server Protocol powerful. The protocol does not dictate how a compiler works. It standardizes the boundary that lets many editors consume language intelligence. AHP aims to standardize the boundary around an active agent session, including progress, permissions, changes, terminals, and reconnect behavior.

The practical payoff is portability. A developer can start a session in one VS Code surface, close a folder, reopen it, and continue from the same state. A remote host can keep the workspace-side process close to the code while a browser or local client observes the run. For long-running coding tasks, that is closer to a persistent worker than to a chat panel.

What builders should take from the design

The first lesson is architectural: treat agent sessions as durable workloads, not disposable conversations. For n8n Lab-style automations, the equivalent is separating the orchestration state from the interface that happens to display it. A Telegram chat, Slack thread, dashboard, and webhook client should not each own a different copy of the run.

The second lesson is to make state replayable. A snapshot plus ordered actions is easier to synchronize, audit, and recover than a collection of ad hoc callbacks. The same pattern can support human approvals, tool-call status, partial results, and reconnects in multi-agent workflows.

The third lesson is to keep the harness replaceable. Teams should be able to change the model runtime without rewriting their monitoring, permission, and session-management layer. AHP does not solve every portability problem, but its separation of harness from host points in the right direction.

There are limits. The protocol is still under active development, so wire types and capabilities may change before a stable release. Client-contributed tools also remain tied to the client that provides them, which means a remote session is not automatically equivalent to a fully portable execution environment. Security teams will need to review how credentials, approvals, workspace access, and reconnect permissions are enforced across hosts.

The larger signal is clear. The next generation of AI development tools will compete less on who owns the chat box and more on who owns the reliable runtime around an agent. Microsoft is trying to make that runtime open enough for other clients and harnesses to plug into, while still keeping VS Code at the center of the workflow.

For builders, the useful pattern is worth copying now: persistent session state, explicit host-client boundaries, replayable events, and model-specific harnesses behind a stable control plane. That is the infrastructure required when agents stop being one-shot assistants and become software workers that continue after the window is closed.

Sources

• Introducing the Agent Host for persistent, portable agent sessions, Rob Lourens, Connor Peet, and Brigit Murtaugh, Visual Studio Code, August 26, 2026.
• Microsoft Visual Studio Code repository, official open-source implementation and protocol context.
• OpenAI Workspace Agents Turn Team Context Into Runtime
• The Agent Control Plane Is AI's Next Infrastructure Battleground