AI NewsInfrastructureAnnouncement
GitHub and Microsoft publish Agent Host Protocol for sessions across devices
GitHub and Microsoft published the Agent Host Protocol. It is an open standard. It lets one agent session continue across VS Code, phone and web.

Why it mattersA team building an agent UI no longer writes a bespoke integration for every surface. One AHP implementation reaches every client the user is on.
GitHub and Microsoft published the Agent Host Protocol on 17 November. It is an open standard. It lets one agent session move between devices. The teams built two independent implementations to test the design. They also published client libraries in six languages.
Connor Peet and Rob Lourens, principal software engineers at Microsoft and GitHub, wrote the post on the GitHub Blog. The repository holds the protocol specification itself.
The problem the standard addresses
Agent surfaces have multiplied. One team may have a web client, a desktop IDE, a mobile app, a cloud harness and a CLI. Each surface holds its own idea of a session. Starting work in one did not mean continuing it in another. Each surface needed a custom integration with every agent vendor. The post describes it plainly: "every client needs its own one-off integration".
AHP introduces a shared protocol between two roles: a client and a host. The host runs the agent and owns the state. The client renders the session and sends actions. A URI identifies each session. A reducer-based state object records the current content. Any number of clients can connect at once, see the same history, and send actions into the same session.
Two implementations, six client libraries
VS Code's implementation is written in TypeScript. GitHub's is written in Rust. The two teams wrote them independently, without sharing code, to confirm the specification is portable. The GitHub team then published client libraries in six languages: Rust, TypeScript, Kotlin, Swift, .NET and Go. A team building an agent surface can pick the language of the surface.
The post describes the behaviour on an unreliable network. The protocol handles network interruptions, reconnections and concurrent client mutations. A dropped connection does not lose the session, because the server still owns the state. Two clients writing at the same time are sequenced on the server side.
Why it matters now
The protocol is a bet on where agent interfaces are going. One session, many surfaces, with the surface chosen by what the user is holding. GitHub and Microsoft now run the same model in their own products. The GitHub Copilot app and VS Code both adopt AHP. A third-party agent that implements AHP reaches both clients without a second integration.
Two things to watch. One, it is a protocol, not a product. Its value grows with each adopter, and shrinks if other agent vendors publish competing specifications. Two, the two implementations are reference code rather than a certified compliance suite. A later agent vendor that writes a third AHP server will test against the two existing clients.
Teams building an agent interface today face a choice. One option is a bespoke integration for each surface. The other is a bet on a shared protocol. The post does not name a target adoption date. It does not name other adopters. It does name the repositories for the protocol and the client libraries. The two teams publish them under an open licence.
Source
This item was written by an AI system from the linked source. Reveneau is responsible for what it publishes.
Get AI News in your inbox
New developer tools, model and agent releases, and how teams are actually using them to release software. Short, and only when there is something worth reading.

