📑 Table of contents

GitHub unveils the Agent Host Protocol: code agent sessions that survive device switches

Agents IA 🟢 Beginner ⏱️ 13 min read 📅 2026-11-18

GitHub unveils the Agent Host Protocol: code agent sessions that outlive your devices

🔎 Your agents work for hours. Your editor, meanwhile, closes.

A code agent refactoring an entire codebase overnight has become routine. What hasn't: being able to follow that work from anything other than the tool that launched it. You start a session in VS Code at the office — and by evening, there's no clean way to check on it from your phone without fragile workarounds.

That's the problem Microsoft and GitHub are tackling head-on with the Agent Host Protocol (AHP), an open standard released under the MIT license and announced on November 17 and 18, 2026, notably covered by the daily news roundup from BrightCoast. Built first into VS Code starting in August 2026, then adopted across GitHub, the protocol makes an agent session accessible from editors, apps, phones, and the cloud — simultaneously.

The stakes go beyond convenience. Agentic work has become multi-device by nature: a developer supervises multiple agents, from multiple clients, across sessions that run for hours. Existing protocols, designed for one-to-one use, were never built for this.


The essentials

  • An open standard, not a closed product: the Agent Host Protocol is published as open source (MIT license) with SDKs in Rust, TypeScript, Kotlin, Swift, .NET, and Go.
  • The problem solved is N:M: multiple clients (VS Code, Copilot app, mobile, cloud sandboxes) around a single long-running agent session, with state synchronized in real time.
  • A host that owns the sessions: a standalone process keeps sessions alive, even after the editor is closed, locally or remotely (SSH, dev tunnels, web).
  • Agent-agnostic: AHP describes the client-side state of the session, not the agent's internal workings. Copilot harnesses (Microsoft Copilot SDK) and Claude (Anthropic's Claude Agent SDK) are already supported via adapters.
  • Young and evolving: the protocol is explicitly "under active development", with breaking changes announced. Worth watching closely, not something to anchor in critical production.

Tool Main use Price (November 2026) Ideal for
Agent Host Protocol Protocol + SDKs (6 languages) Free (MIT) Developers who want to expose their agent sessions
VS Code + Agent Host Local host + Agent Sessions client Free Getting started without infrastructure
GitHub Copilot Agent harness via Copilot SDK From ~$10/month (check github.com) Teams already on the GitHub ecosystem
Claude Agent SDK Claude harness via AHP adapter Free SDK, API costs depend on model (check anthropic.com) Agents powered by Claude Opus 4.7 or Sonnet 4.6
Hostinger VPS to host a remote AHP host From ~€3/month (check hostinger.com) Self-hosting sessions accessible from anywhere

What is the Agent Host Protocol, exactly?

AHP is an open protocol that describes the client state of an agent session — not its internal workings — so that multiple independent applications can display and drive the same session. That's the definition given by GitHub engineers, and it has an immediate consequence: AHP doesn't replace any existing agent.

The team sums up the concept in three words: a "display protocol". Actions + state = interface. The protocol doesn't decide which model reasons, which tools get called, how the agent plans. It guarantees one thing only: what you see of the session — messages, terminal, changesets, pending approvals — is identical everywhere, for every connected client.

The N:M problem, explained simply

Until now, the agentic ecosystem works 1-to-1: one client, one agent, one session. Close VS Code, and your session lives or dies with it. Open a mobile app: the session doesn't exist for it.

AHP flips the logic. The host — a standalone process — becomes the owner of the sessions. It stays active beyond the editor's closure, locally (VS Code's utility process) or remotely (SSH, dev tunnels, web). Clients become surfaces for display and control: they connect, disconnect, come back. The problem shifts from 1:1 to N:M, and that's exactly what the protocol claims as its raison d'être.

A deliberately bounded protocol

This boundedness is a strength, not a limitation. Because AHP ignores the agent's internals, any harness can plug into it: Copilot via its SDK, Claude agents via the Claude Agent SDK, and others tomorrow.

The choice of model remains your business. Whether your agent runs on GPT-5.5 (98.2 on the June 2025 agentic leaderboard) or on a self-hosted model like Kimi K2.6 (88.1), AHP doesn't care — and that's a good thing. Session portability must never become a model lock-in.


How it works: channels, immutable state and write-ahead

AHP rests on four explicit engineering requirements: synchronized multi-client state, lazy loading of large content, write-ahead with reconciliation, forward-compatible versioning. Each one addresses a classic pitfall of distributed real-time (official documentation).

Channels identified by URI

Every command and every notification carries a channel parameter in URI form. Four base channels: root, session, chat, terminal. Dispatch happens without per-method deserialization — simpler, faster, fewer implementation errors.

Optional channels extend the scope: automations, additional terminals, MCP relays, OpenTelemetry telemetry. Well-thought-out extensibility, sparing the protocol from having to anticipate everything in its first version.

Immutable state, mutated by pure reducers

The technical core fits in one sentence: an immutable state, mutated only by pure reducers. Clients apply their actions optimistically, then reconcile them when the server responds — a model directly inherited from modern front-end architectures.

Two concrete benefits. First, reconnection: if your phone loses the network, the host keeps going on its own, and the client replays what it missed upon return. Then, auditability: a replayable action stream is also a log of everything the agent did — a topic that has become central in the community, as shown by Prime Agent, GitHub's #1 repo (17,500 stars) that makes coding agents self-improving — and auditable.

Lazy loading and forward compatibility

Large content — diffs, logs, terminal output — travels by reference, not by value. A mobile client doesn't need to download tens of megabytes of logs to display a relevant summary.

And forward-compatible versioning changes the lives of integrators: a new client can connect to an old server. Without this property, every client update would break the entire ecosystem — the classic mistake of all proprietary protocols.


AHP vs MCP vs A2A: complementary, not competing

AHP does not compete with MCP or A2A: it operates at a different layer — that of the session and its display — and even interfaces with both.

Protocol Championed by What it standardizes Layer
MCP (November 2024) Anthropic Agents' access to tools and data Agent ↔ tools
A2A (April 2025, Linux Foundation since June 2025) Google, then Linux Foundation Cooperation between autonomous agents Agent ↔ agent
AHP (November 2026) Microsoft / GitHub Session state and multi-client control Clients ↔ session

The three combine. An agent can consume its tools via MCP, cooperate with other agents via A2A, and expose its session to all your devices via AHP. Cohabitation is designed in from the start: AHP includes an optional MCP relay channel, and an AHP-ACP Gateway already connects the ACP ecosystem.

This stratification is the true signal of maturity in 2026. Every layer of the agentic stack eventually gets its own standard — as we saw when Poppy established its personal agent protocol, adopted by Shopify stores worldwide (our analysis). AHP lays claim to the session layer, the most visible one for the end user.


What this concretely changes for developers

Three immediate changes: your sessions no longer die with the editor, you can approve or cancel from any client, and you're no longer a prisoner of a single harness.

Scenario 1: reviewing from the couch

You kick off a migration at the end of the day with an agent powered by Claude Sonnet 4.6. In the evening, you reopen the same session from your phone: messages, terminal, pending changesets. You review, you comment, you don't relaunch anything.

Scenario 2: remote tool approval

The host exposes tool approval, changeset review, and cancellation from any connected client. An agent asks to run a sensitive command at 11 p.m.? You make the call from your couch, without firing up an IDE. It's a shift in posture: the human becomes a supervisor again, not an operator tied to a workstation.

Scenario 3: switching harnesses without losing history

The AHP adapters for Copilot SDK and Claude Agent SDK lay the groundwork for a market of interchangeable harnesses. Anthropic is pushing in the same direction with the opening of Claude Managed Agents in self-hosted mode (our article): the agentic stack is shedding its silos, layer by layer.

To choose the agent that will run behind your host, our comparisons of the best autonomous AI agents and the best AI tools for code remain the most up-to-date entry points.


The ecosystem is already taking shape — and fast

Barely announced, AHP is not an isolated prototype: the official repo already shows around 463 stars, 164 forks, and 86 open issues — the sign of a community that is testing, breaking, and documenting in real time.

Third-party servers from day one

The server ecosystem is already well stocked. pi-ahp hosts the pi agent. ahpd offers a plugin-driven server with user, permission, and usage management — plus Claude and ACP plugins, sandboxed computers, and a web UI. Add to that hydra-ahp, the AHP-ACP Gateway, and above all AgentConnect, which brings Claude Code, Codex, and other ACP agents into Slack, Telegram, or Discord.

This pace recalls other moments when the community outpaced the vendors: OpenCode and its 8 million developers for 172,000 GitHub stars (our analysis), or the wave of "skills" establishing itself as the standard for extending coding agents (details here).

Clients are following

On the client side: VS Code ships the Agent Sessions client, AHPX offers a CLI/Node client, ahpc is a terminal client that also doubles as an MCP server, and ahpw is a web interface. The host ↔ clients loop promised by the protocol is therefore already working end to end.

For those who want to push autonomy further — agents that run on their own, locally, without depending on the cloud — our guide on open source AI agents with Ollama pairs well with a self-hosted AHP host. A VPS at a few euros per month from Hostinger is enough to run ahpd and expose your sessions via SSH or dev tunnels.


How to get started with AHP today

The shortest path is a single command, from VS Code:

code agent host

This command starts the Agent Host locally: an autonomous process that owns your sessions and stays active after the editor is closed. You reconnect to it from the Agent Sessions client in VS Code, or from any third-party AHP client.

Three tips to get off to a good start. Start locally, without exposing anything — the attack surface of an agent host is nothing to take lightly. Then deliberately test reconnection: cut the network, come back, verify the reconciliation. Finally, hook up a single harness first (Copilot or Claude via the official adapters) before dreaming up multi-harness architectures.

And keep in mind that your agent's quality remains the limiting factor. A session protocol won't make up for a bad model: our comparison of the best LLMs for coding helps you pick the brain — AHP only takes care of the dashboard.


The Limitations: Breaking Changes, Adoption, and Blind Spots

AHP is promising but young: the protocol is explicitly "under active development," with breaking changes announced in black and white. Three blind spots deserve your attention.

What the Protocol Doesn't Solve

AHP doesn't standardize agent memory, context sharing between agents, or fine-grained multi-user authentication. That's the job of MCP, A2A, or servers like ahpd that layer users and permissions on top. If you were hoping for a "total agentic protocol," this isn't it — and that's probably just as well.

The Uncertainty of Adoption

Microsoft and GitHub carry a lot of weight, but the standards battle is also being fought elsewhere: JetBrains, Cursor, and the other vendors have announced nothing. The protocol is agent-agnostic on paper; what remains to be seen is whether competing vendors play along or ship their own proprietary variants.

Contractual Fragility

Building on a protocol that announces breaking changes means accepting a recurring maintenance cost. Pin your versions, isolate the AHP layer behind an abstraction, and keep an eye on the 86 open issues in the repo: that's where breaking changes get announced first.


❌ Common Mistakes

Mistake 1: Confusing AHP with an "MCP killer"

AHP doesn't wire agents to tools; it synchronizes session state across multiple clients. The two protocols complement each other — AHP even offers a native MCP relay. Wanting to "replace MCP with AHP" in your stack simply makes no sense.

Mistake 2: Exposing your AHP host on the internet without thinking

A remote host controls your agents, your terminals, your files. As it stands, fine-grained access management goes through servers like ahpd (users, permissions, usage) or through SSH tunnels. Never expose a bare AHP host on the public web.

Mistake 3: Building a product on a shifting API

The protocol announces breaking changes. Pin versions, abstract the AHP layer, systematically test reconnection. Otherwise, every major protocol release will become a production incident.

Mistake 4: Believing that a portable session makes the agent portable

AHP carries session state, not the agent's memory or internal context. Switching clients: yes. Switching agents mid-session while keeping their entire reasoning history: no. That's not the same problem, and AHP doesn't claim to solve it.


❓ Frequently Asked Questions

Is AHP free and open source?

Yes. MIT license, public repo microsoft/agent-host-protocol (around 463 stars at the time of publication), SDKs in Rust, TypeScript, Kotlin, Swift, .NET and Go. Your only costs: the infrastructure hosting the host and the API consumption of the models behind your agents.

Does AHP replace MCP?

No. MCP (Anthropic, November 2024) connects agents to tools and data; AHP synchronizes session state across multiple clients. AHP even includes an optional MCP relay channel — proof that the two are designed to coexist, not to compete.

Can I use AHP with non-Microsoft agents?

Yes, that's the very principle of the protocol. AHP adapters already support Anthropic's Claude Agent SDK, and AgentConnect lets Claude Code, Codex and other ACP agents talk to the protocol. AHP describes the client state of the session, never the agent itself.

How do I start an AHP session?

From VS Code, the code agent host command starts a local host. For a remote host, the documentation covers SSH, dev tunnels and web deployment. Third-party servers like ahpd offer a plugin-driven alternative with user and permission management.

Which model should you choose behind an AHP host?

AHP is agnostic, so it all depends on your use case: Claude Opus 4.7 or GPT-5.5 for complex agentic tasks, Kimi K2.6 or GLM-5 self-hosted for full control. Our guide to the best LLMs for AI agents covers these trade-offs in depth.


✅ Conclusion

The Agent Host Protocol doesn't reinvent the agent: it reinvents the way you supervise it — a session that no longer dies when you close your editor, and that you can control from any device — and it might just be the missing piece for multi-device agentic work. To take the plunge, our guide on creating an AI agent gives you the basics to connect your first agent to this type of infrastructure.