Skip to content
Innovation & Growth

GitHub moves Copilot agent sessions out of the editor window

Its Agent Host Protocol lets an AI agent keep working while you switch devices. The work now depends on the host, not the app.

W
WebPulse Newsroom
AI-assisted · 4 min read
Share on X LinkedIn
GitHub moves Copilot agent sessions out of the editor window

Graphic: WebPulse, drawn from the sourced facts in this story.

In brief
  • GitHub Engineering says its Agent Host Protocol lets Copilot agent sessions continue across devices, instead of ending when a VS Code window closes.
  • The agent now lives in a host that many clients can reach, so control and oversight move to the host.
  • Leaders should ask who can connect clients to agent hosts, where sessions are recorded, and what happens when a device is lost.

The agent used to die with the window

An AI agent that works for hours cannot be tied to a window that you might close in minutes. GitHub's engineers say this is the problem they set out to fix. The idea behind their answer is simple. The unit of work is no longer the app. It is the session.

GitHub Engineering published the account on November 17. It says models can now work "for hours or even days" on their own. People still need to check in from wherever they are.

The original design could not do that. GitHub Copilot began in VS Code as an extension that carried its own harness, the software that runs the agent. GitHub says closing the window removed the agent. Updating VS Code stopped every agent, because the application restarted.

One integration per product stopped scaling

The trouble spread beyond the editor. GitHub says the Copilot app and its iOS and Android mobile apps were each building their own link to cloud-based agents. Each solved the problem for one product only.

GitHub's answer is the Agent Host Protocol, or AHP. It is an open standard that lets any client talk to the same agents. GitHub says it was built first in VS Code and is now used across GitHub.

This is a familiar pattern. Email became useful when any program could talk to any mail server. GitHub is making a similar bet for agent sessions, though this account does not show how far outside GitHub it has spread.

How it works

AHP is organised around "channels", each identified by a URI. Every server must support three: root, session and chat. Servers may add others for terminals, MCP extensions or OpenTelemetry reporting.

Each channel holds a state object, and the server decides what that state is. Clients send actions. Some actions change the state. Others trigger effects, such as sending a chat message.

This design helps when the network is poor. GitHub says a reconnecting client resends the actions it had queued and shows a loading state. Nothing counts as settled until the server has reconciled the actions and confirmed them.

The protocol also leaves agent behaviour alone. GitHub says agents are changing too quickly to encode how they work. AHP describes how people interact with agents instead.

The cost of building underneath

The move was a large piece of work. GitHub says the old Copilot Chat extension supplied all of VS Code's AI features. It describes a codebase of more than 400,000 lines of TypeScript (tests excluded), built over three years and tied to the VS Code window. It depended on the VS Code extension API, which a standalone host does not have. GitHub calls the move "a big transition" and says the team built a new harness on the Copilot SDK.

GitHub also runs two independent hosts. VS Code's is written in TypeScript. GitHub's cloud host has to run across a wider range of infrastructure and security constraints, so it is a separate implementation, written in Rust.

When the teams compared their work, they found three kinds of difference. Some extensions were GitHub-specific, such as links to project boards. Some exposed gaps, such as early versions being unable to represent shell output not backed by a PTY. Some were bad assumptions, such as a client expecting a particular structure in session URIs.

GitHub's conclusion is that a protocol with one implementation is not truly portable. Two teams building separately gave it evidence that it is.

Questions for leaders

The article is GitHub's own account. It gives no performance figures and says little about access control. The lesson below is the publication's view, not a finding from GitHub.

An agent that outlives the window is a standing process that many devices can reach. Each new client, from a phone to a watch app, becomes another place where someone can steer it. GitHub lists libraries in six languages and says people have built Kanban tools and smart watch apps on AHP.

Leaders can ask their teams four things:

• Which agent hosts run in our environment, and who can connect a new client to them? • Where is a long-running session recorded, and who can read it? • What happens to work in progress when a device is lost? • Do our tools support open protocols like AHP, or does each need its own integration?

The agent no longer lives in one application. Control over it now sits in the host, and that is where oversight needs to go.

Produced by the WebPulse Newsroom with AI assistance from the original reporting credited below, and checked against that source by our editorial review. How we use AI.
Original reporting: GitHub Engineering.