Een agent voor jullie eigen proces?
Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.
Dennis Claassen
AI-trainer · 35+ teams getraind
Key takeaways
- Microsoft publiceerde op 28 oktober 2026, met VS Code 1.144, versie 1.0 van het Agent Host Protocol (AHP): een open, MIT-gelicenseerde standaard waarmee een client (een UI of app) met een AI-coding-agentsessie praat, los van welke agent dat is.
- AHP standaardiseert de sessie, niet de agent. Het protocol bepaalt hoe een client en een "Agent Host" elkaar synchroon houden. Het bepaalt niet hoe een agent redeneert, welke tools hij aanroept of welk model erachter draait: dat doen Copilot, Claude Code en Codex nog altijd zelf.
- De grootste valkuil: een open protocol is geen garantie op toegang. Zet jouw organisatie Copilot's beheerde instellingen aan, dan schakelt VS Code de Claude- en Codex-harnessen uit totdat een beheerder dat expliciet toestaat, los van wat AHP zelf toelaat.
- We lieten een AI-model, blind voor de documentatie, een AHP-client schrijven. De code zag er overtuigend uit en bevatte vier concrete fouten: een niet-bestaande hoofdklasse, het verkeerde import-pad, een verzonnen handshake-veld en een niet-bestaand actietype.
- Er bestaat al een klein ecosysteem: client- en hostbibliotheken in zes talen, en onafhankelijke projecten die Claude Code en Codex via AHP naar Slack, Telegram en een eigen webinterface brengen.
Gebruikt jouw team GitHub Copilot in VS Code, en daarnaast Claude Code of Codex, dan veranderde er op 28 oktober 2026 iets dat weinig Nederlandse IT-teams opmerkten: Microsoft publiceerde versie 1.0 van het Agent Host Protocol, een open standaard die moet voorkomen dat je vastzit aan één interface om met een AI-coding-agent te praten. We testten zelf wat die belofte waard is, onder meer door een AI-agent blind een eigen client te laten bouwen. Hieronder lees je wat het protocol regelt, waar het je als Nederlands team wél en niet uit de brand helpt, en wat je er vandaag al mee kunt testen.
Wat is het Agent Host Protocol precies?
Het Agent Host Protocol (AHP) is de taal waarin VS Code's "Agent Host" met zijn clients praat: een los proces dat agentsessies draait (Copilot, Claude Code of Codex) en die laat voortbestaan ook als je editorvenster sluit. Volgens de officiële architectuurdocumentatie van VS Code, die we zelf raadpleegden, is AHP "an open, agent-agnostic protocol between a host and its clients": JSON-RPC-berichten met onveranderlijke status en "pure reducers", vergelijkbaar met Redux. De host is de enige bron van waarheid; elke client krijgt eerst een momentopname en daarna alleen de wijzigingen, in volgorde. Valt de verbinding weg, dan krijgt de client bij terugkeer de gemiste acties of een verse momentopname.
Dat klinkt abstract, maar de reden is concreet. Vóór VS Code 1.129 (16 juli 2026, onafhankelijk bevestigd door HelpNetSecurity) stopte een agentsessie zodra je je editorvenster sloot. Agent Host maakte daar een eind aan door de sessie in een eigen proces te laten draaien, lokaal of op afstand. AHP is de protocol-laag die dat proces bereikbaar maakt voor méér dan alleen VS Code: in theorie kan elke client die de standaard spreekt meekijken.
Wat is er nieuw sinds VS Code 1.144?
VS Code 1.144, uitgebracht op 28 oktober 2026, maakte AHP voor het eerst een eigen, versienummerde standaard: versie 1.0, onder MIT-licentie, met een eigen specificatierepository op GitHub. Microsoft publiceert clientbibliotheken in zes talen (TypeScript, Rust, Kotlin, Go, Swift, .NET), met als doel: "an easy way to build custom UI's for your agents, or build agent platforms that plug into any UI that speaks it." Vanaf deze versie voeg je met Agents: Add Remote Agent Host... een eigen agent host toe aan VS Code, of start je met code agent host zelf een standalone host.
Onafhankelijk technologiejournalist David Ramel bevestigt in Visual Studio Magazine dat deze release "consolidates several previously introduced capabilities while adding new functionality", met AHP als kernonderdeel naast onder meer de gelijktijdige algemene beschikbaarheid van GitHub Copilot Fusion, dat los van AHP staat: Fusion kiest modellen, AHP regelt hoe een client bij een sessie komt.
Wat verandert dit voor een Nederlands team?
Voor de meeste teams verandert er op korte termijn niets automatisch. Wat er wel verandert, zit op twee niveaus.
Eerst de developer die vandaag al met meerdere agents werkt. Gebruikt je team Copilot in VS Code naast Claude Code, dan draaien die harnessen sinds eerdere VS Code-versies al via de Agent Host. AHP maakt dat mechanisme nu een gepubliceerde, versiestabiele standaard in plaats van een intern VS Code-detail: een sessie die je in VS Code start, kun je straks ook vanuit een ander, AHP-sprekend programma volgen of overnemen, zonder dat die app een eigen integratie per agent moet bouwen. Het bewijs dat dit geen toekomstmuziek is: er bestaan al onafhankelijke clients en hosts, zoals een terminal-client met ingebouwde MCP-server (ahpc), een webclient voor elke AHP-server (ahpw), en een project dat Claude Code en Codex-sessies via AHP naar Slack, Telegram en Discord brengt (AgentConnect), precies het soort integratie dat vroeger een eigen, fragiele koppeling per agent vereiste.
Een onafhankelijke, kritische analyse van ontwikkelaar RohitAI, geschreven toen AHP nog in een vroege draftversie zat, waarschuwt voor een risico dat de 1.0-release niet wegneemt: "The ecosystem could trade editor lock-in for host lock-in." Omdat de Agent Host bepaalt hoe elk agent-event naar gemeenschappelijke status wordt vertaald, bepaalt wie die host beheert ook de policy, opslag en zichtbaarheid van je sessies. Vandaag is VS Code zelf vrijwel de enige echte serverimplementatie; onafhankelijke, interoperabele hosts zijn er nog maar beperkt. Vraag jezelf de komende maanden dus niet alleen af of een tool AHP spreekt, maar ook wie de host beheert die jouw sessies vertaalt, en of je die host zelf kunt vervangen.
Ten tweede de IT-manager die beslist welke agents het team mag gebruiken. Voor jou verandert AHP het speelveld niet: de knop waarmee je Claude- en Codex-sessies toestaat of blokkeert, staat los van dit protocol. Dat brengt ons bij de grootste valkuil.
De grootste valkuil: een open protocol is geen garantie op toegang
Het is verleidelijk om te denken dat een open, vendor-neutraal protocol betekent dat je voortaan vrij kunt wisselen tussen Copilot, Claude Code en Codex. Dat is maar half waar, en de helft die niet waar is, kost een IT-manager het meest als hij het over het hoofd ziet.
AHP standaardiseert de verbinding tussen een client en een sessie. Het zegt niets over welke harness die sessie mag starten. Diezelfde officiële architectuurdocumentatie die we hierboven aanhaalden, zegt het met één zin die je zelf kunt nalezen: "Claude and Codex harnesses are disabled when Copilot enterprise-managed settings apply, unless your administrator explicitly permits them." Dat mechanisme bestond al vóór AHP een eigen naam kreeg, en we beschreven het destijds in detail, inclusief een acht dagen durend supportgeval: zie onze gids over GitHub Copilot agent mode en de Claude-harness voor dat volledige verhaal.
Het nieuwe inzicht van vandaag is niet dat mechanisme zelf, maar waar de grens precies loopt: de transportlaag (AHP) is open en versienummerd, de toegangslaag (welke harness mag draaien) blijft een keuze van je eigen organisatie-instellingen, los van wat het protocol zelf toelaat. Werkt je team nu al met zowel Copilot als Claude Code, controleer dan vóór je een sandbox- of permissiebeleid aanzet of dat beleid per ongeluk ook je Claude- of Codex-toegang blokkeert. AHP zelf verandert daar niets aan, hoe open het protocol ook is.
Hoe verhoudt het Agent Host Protocol zich tot MCP?
Een vaak gehoorde verwarring: is AHP niet gewoon een nieuwe naam voor MCP? Nee. MCP (Model Context Protocol) standaardiseert hoe een agent tools en databronnen aanroept: een database doorzoeken, een ticket aanmaken, een bestand lezen. AHP standaardiseert een laag erboven: hoe een client (de UI die jij ziet) een agentsessie volgt en bestuurt, los van welke tools die agent daarbinnen gebruikt. Vuistregel: MCP zit tussen de agent en de buitenwereld van tools, AHP zit tussen de agent en de schermen die ernaar kijken. Een Copilot-sessie kan dus prima MCP-servers aanroepen, terwijl diezelfde sessie via AHP in VS Code, in een browser, of in een derde app wordt getoond.
Probeer dit vandaag: wat een AI-model ervan bakt zonder de documentatie
Microsoft claimt zelf in de officiële documentatie dat "agents are good at making clients and hosts using them", met minimale prompting. Dat is een stevige claim, en makkelijk te testen.
Dit voorbeeld is geconstrueerd om de claim zelf te toetsen: de code hieronder is wel echt door een losse AI-sessie geschreven, zonder dat die sessie de AHP-documentatie kreeg.
Dit was de letterlijke opdracht aan die sessie, die niet wist welke fouten we zochten en geen documentatie kreeg:
Schrijf een kort Node.js/TypeScript-script (15-30 regels) dat:
1. Verbindt met een lokale Agent Host op een websocket-URL met een
connectietoken.
2. De handshake/initialisatiestap uitvoert die je nodig denkt te hebben.
3. De huidige agentsessies opvraagt en hun ID en status toont.
4. Zich abonneert op één sessie en nieuwe chatberichten logt.
Je hebt geen documentatie: gebruik alleen de gangbare conventies van
vergelijkbare protocollen (LSP, Redux-achtige state-sync). Schrijf
concrete, werkende code, geen voorbehoud dat je de exacte API niet kent.
Dit is de kern van wat die sessie opleverde:
import { AgentHostClient, ConnectionState } from "@microsoft/agent-host-protocol";
const HOST_URL = "ws://127.0.0.1:9423";
const CONNECTION_TOKEN = "ahp_local_7f3a9c2e1b6d4f58";
async function main() {
const client = new AgentHostClient({
url: HOST_URL,
token: CONNECTION_TOKEN,
});
await client.connect();
const { protocolVersion } = await client.initialize({
clientInfo: { name: "ahp-quick-client", version: "0.1.0" },
});
const { sessions } = await client.listSessions();
for (const session of sessions) {
console.log(`session ${session.id}, status: ${session.status}`);
}
client.onStateUpdate(sessions[0].id, (action) => {
if (action.type === "chat/messageAppended") {
console.log(`${action.payload.role}: ${action.payload.content}`);
}
});
}
main();
Dit leest als goede code, en dat is precies het risico. Vergeleken met de echte TypeScript-clientdocumentatie, die we zelf naast deze uitkomst legden, zitten er vier concrete fouten in:
- De hoofdklasse heet
AhpClient, nietAgentHostClient. Een verzonnen naam die klinkt als iets wat zou kunnen bestaan. - De client zit niet in het hoofdpakket. Het pakket
@microsoft/agent-host-protocolzonder subpad geeft alleen types en reducers, zonder I/O. De echte client komt uit het subpad@microsoft/agent-host-protocol/client. - Je kunt geen
{url, token}rechtstreeks aan de client geven.AhpClientis transport-onafhankelijk: je bouwt zelf eenWebSocketTransport(uit het subpad/ws) en geeft die apart mee. - Het actietype
chat/messageAppendedbestaat niet. De echte conventie volgt wel hetzelfde patroon (domein/actie), maar in de officiële actietabel van AHP heet de binnenkomende tekst van een agentchat/delta(een streamend tekstfragment) enchat/responsePart(een nieuw onderdeel van het antwoord), nooitchat/messageAppended.
Zo ziet een versie eruit die de vier fouten repareert, met alleen de onderdelen die we zelf tegen de officiële clientdocumentatie konden verifiëren:
import { AhpClient } from "@microsoft/agent-host-protocol/client";
import { WebSocketTransport } from "@microsoft/agent-host-protocol/ws";
const HOST_URL = "ws://127.0.0.1:9423";
const CONNECTION_TOKEN = "ahp_local_7f3a9c2e1b6d4f58";
async function main() {
const transport = new WebSocketTransport(HOST_URL, { token: CONNECTION_TOKEN });
const client = new AhpClient(transport);
await client.connect();
// protocolVersions is een lijst (meest-gewenst eerst), geen los veld
const { protocolVersion, sessions } = await client.initialize({
protocolVersions: ["1.0.0"],
clientInfo: { name: "ahp-quick-client", version: "0.1.0" },
initialSubscriptions: ["ahp-root://"],
});
console.log(`verbonden op protocolversie ${protocolVersion}`);
for (const session of sessions ?? []) {
console.log(`sessie ${session.id}, status: ${session.status}`);
}
// chat/delta en chat/responsePart zijn de echte, gedocumenteerde
// actietypes voor binnenkomende tekst, geen verzonnen naam.
for await (const envelope of client.subscribe("ahp-chat://<chat-id>")) {
if (envelope.action.type === "chat/delta" || envelope.action.type === "chat/responsePart") {
console.log(envelope.action);
}
}
}
main();
Check vóór je dit zelf draait altijd de meest recente README van je taal: methodesignaturen (zoals wat subscribe teruggeeft) kunnen tussen versies verschuiven, terwijl de klassenaam, het importpad en de actietypes hierboven al vaststaan.
De conclusie is genuanceerder dan "het model kan het niet": de structuur (een host als bron van waarheid, een handshake, sessies en acties) klopt, want die is ook zonder documentatie publiek te vinden. De exacte namen van klassen, subpaden en actietypes zijn dat niet. Microsofts eigen claim gaat over agents die een client bouwen met de documentatie erbij (de AHP-website: "most agents can build fully functional clients and hosts with these packages and minimal prompting"). Zonder die documentatie krijg je plausibele, stille fouten: code die compileert, maar op een ontbrekende export stukloopt.
Beslisregel: moet jouw team hier iets mee?
| Als dit voor jou geldt | Dan | Waarom die drempel daar ligt |
|---|---|---|
| Je team gebruikt alleen Copilot, in alleen VS Code | Niets te doen | AHP verandert niets aan een situatie met één client en één harness; je merkt het pas zodra een tweede client of harness meedoet |
| Je team gebruikt Copilot én Claude Code of Codex naast elkaar in VS Code | Check vóór je een sandbox- of permissiebeleid aanzet of dat beleid Claude/Codex blokkeert | Dit is het scenario uit de grootste valkuil hierboven: de blokkade triggert op een organisatie-instelling, niet op een bewuste "Claude uitzetten"-keuze |
| Je bouwt zelf interne tooling die moet meekijken met agentsessies (een dashboard, een Slack-integratie) | Overweeg een AHP-client in plaats van een eigen integratie per agent | Eén AHP-client werkt in theorie tegen elke host die de standaard spreekt, in plaats van een onderhoudslast per leverancier |
| Je laat een AI-model zelf productiecode tegen een nieuw protocol schrijven, zoals AHP | Geef de officiële clientdocumentatie altijd mee in de prompt | Ons eigen voorbeeld hierboven laat zien dat vier van de kernonderdelen (klassenaam, importpad, transport, actietype) zonder die documentatie fout gaan |
| Je werkt niet met AI-coding-agents in VS Code | Niets te doen | AHP is een protocol voor agentsessies binnen VS Code's Agent Host; zonder die agents is er niets om te synchroniseren |
Wat je mag verwachten, en hoe je dat na zeven dagen meet
Het controleren van de valkuil hierboven kost geen dag: één instelling nalopen en, indien nodig, één uitzondering vragen aan je beheerder. Wil je zelf een AHP-client bouwen, dan ligt dat anders. Uit onze trainingen zien we dat een eerste werkende proof-of-concept met een gedocumenteerde client-SDK meestal binnen een halve tot een hele dag staat, mits je wél de documentatie meegeeft aan wie het bouwt, mens of AI. Een stabiele, productierijpe integratie is een ander project: reken op meerdere dagen, precies het deel dat de officiële clientbibliotheken (reconnect-supervisor, generatie-gecheckte handles) voor je proberen op te lossen.
Meet na zeven dagen drie dingen, zonder extra tooling:
- Of je sandbox- of permissiebeleid Claude- of Codex-sessies blokkeert, voor teams die beide gebruiken. Open gewoon een testsessie in elke harness. Geen van beide start, en niemand klikte bewust "uitzetten"? Dan is dit je signaal.
- Of een AHP-client die je zelf (of een AI-model) bouwde, ook echt tegen de documentatie is nagekeken. Leg de code naast de clientbibliotheek van je gekozen taal; ontbrekende subpad-imports zijn de meest voorkomende, stille fout.
- Of iemand in je team AHP inmiddels gebruikt om een sessie in een andere app dan VS Code te volgen. Dat is het concrete teken dat de interoperabiliteit verder komt dan een demo.
Wat het Agent Host Protocol niet oplost
- Het bepaalt niet welke harness mag draaien. Dat is een apart besluit van je organisatie-instellingen of je Copilot-licentie, los van het protocol.
- Het standaardiseert niet hoe een agent redeneert, welke tools hij aanroept of welk model erachter draait. Dat blijft aan de harness zelf (Copilot, Claude Code, Codex) en, voor tools, aan MCP.
- Het garandeert geen compatibiliteit tussen elke client- en hostversie. Een server die geen van de aangeboden protocolversies spreekt, moet de verbinding met een expliciete foutcode afwijzen; AHP is bovendien nog jong, dus clients en hosts van verschillende leeftijden kunnen elkaar nog tegenkomen.
- Het maakt een AI-model niet automatisch een correcte AHP-client-schrijver. Ons voorbeeld hierboven laat zien dat vier kernonderdelen zonder documentatie fout gingen.
- Het is geen vervanging voor eigen reconnect- en foutafhandelingslogica. De officiële clientbibliotheken bieden daar bouwstenen voor, maar je moet ze zelf gebruiken; een los script zoals ons voorbeeld doet dat nog niet.
Doe dit deze week
Check je permissiebeleid als je Copilot én Claude Code of Codex gebruikt
Start in elke harness een nieuwe testsessie. Lukt het starten van een Claude- of Codex-sessie niet meer, controleer dan of er recent een sandbox- of permissie-instelling is aangezet, en vraag je beheerder om een uitzondering als dat per ongeluk zo staat.
Vraag de AHP-endpoints van je eigen editor op
Draai
code agent endpointsin een terminal met VS Code 1.144 of hoger om de lokale AHP-verbinding van je eigen Agent Host te zien. Dat is de eerste stap om een eigen client, of een bestaand project zoalsahpw, daarop aan te sluiten.Laat een AI-model een eerste AHP-client schetsen, mét documentatie erbij
Gebruik de prompt hieronder, en geef de AI-sessie expliciet de link naar de clientdocumentatie van jouw taal mee. Vergelijk de uitkomst met ons geconstrueerde voorbeeld hierboven: zie je een verzonnen klassenaam, een ontbrekend subpad-import of een verzonnen actietype, dan weet je meteen waar je moet corrigeren.
#CONTEXT: Je bent een developer die een klein, intern dashboard wil bouwen
dat meekijkt met AI-coding-agentsessies in VS Code, via het Agent Host
Protocol (AHP).
#DOEL: Een werkend, kort TypeScript-script dat verbindt met een lokale
Agent Host, de actieve sessies toont en nieuwe berichten in één sessie
logt.
#WERKWIJZE:
1. Vraag me eerst alleen om: de taal waarin ik werk (TypeScript, Rust,
Kotlin, Go, Swift of .NET) en of ik al een lokale Agent Host draaiend
heb (via `code agent endpoints`).
2. Baseer elke import, klassenaam en methode-aanroep uitsluitend op de
officiële clientdocumentatie van die taal; verzin nooit een klasse-
of subpadnaam die alleen "logisch" klinkt.
3. Lever het script met een korte toelichting per stap: verbinden,
handshake, sessies opvragen, op status-updates abonneren.
#BELANGRIJKE REGELS:
- Gebruik alleen methode- en klassenamen die letterlijk in de
meegegeven documentatie staan.
- Benoem expliciet welke onderdelen (transport, reconnect-logica)
de officiële library al voor je regelt, zodat ik dat niet dubbel bouw.
- Controleer vóór je antwoordt of elke import overeenkomt met een echt
gedocumenteerd subpad.
#BEPERKINGEN:
- Geen productierijpe foutafhandeling nodig voor een eerste proof-of-concept.
- Geen aannames over welke harness (Copilot, Claude, Codex) in de sessie draait.
Wil je dat jouw team dit soort agent-integraties met de juiste controle opzet, in plaats van losse scripts die toevallig werken? In de Agent Sprint bouw je in een dag een eerste agent-toepassing met het juiste niveau van controle. Twijfel je breder over welke AI-coding-tools bij je team passen, dan is de AI Werksessie de volgende stap, of bekijk ons volledige aanbod in trainingen.
AI-training
Wil je AI leren inzetten?
In onze praktische trainingen leer je hoe je ChatGPT, Claude en andere AI-tools effectief inzet voor jouw werk.
Info
Stand van zaken op 18 november 2026. Het Agent Host Protocol staat op versie 1.0, gepubliceerd op 28 oktober 2026 met VS Code 1.144, onder MIT-licentie. Microsoft publiceert clientbibliotheken in zes talen (TypeScript, Rust, Kotlin, Go, Swift, .NET). Claude- en Codex-harnessen worden uitgeschakeld zodra Copilot's beheerde instellingen van toepassing zijn, tenzij een beheerder dat expliciet toestaat. Protocolversies, taalondersteuning en dit beleid kunnen wijzigen; check de officiële Agent Host Protocol-website en je eigen VS Code-versie voor je hierop plant.
Bronnen
- Microsoft, Agent Host architecture. Primaire bron voor de werking van de Agent Host, AHP zelf, en de letterlijke zin over het uitschakelen van Claude- en Codex-harnessen onder beheerde instellingen, zelf geopend op 18 november 2026.
- Microsoft, Visual Studio Code 1.144 release notes, 28 oktober 2026. Primaire bron voor de publicatie van AHP 1.0, de zes clienttalen, en de commando's
Agents: Add Remote Agent Host...encode agent host, zelf geopend. - Microsoft, Agent Host Protocol repository en website. Bron voor de MIT-licentie, de lijst onafhankelijke clients en hosts (waaronder
ahpc,ahpwen AgentConnect) en de TypeScript-clientdocumentatie waartegen we het codevoorbeeld controleerden, zelf geopend. - David Ramel, VS Code 1.144 Unleashes Copilot Fusion, AI Image Generation and Computer Use, Visual Studio Magazine, 28 oktober 2026. Onafhankelijke, niet aan Microsoft gelieerde bevestiging van de release-inhoud, zelf geopend.
- HelpNetSecurity, VS Code agent host runs Copilot, Claude, and Codex in a dedicated process, 16 juli 2026. Onafhankelijke, vroege bevestiging van de Agent Host-architectuur vóór AHP een eigen versienummer kreeg, zelf geopend.
- RohitAI, VS Code's Agent Host Protocol Turns Agent Sessions Into Infrastructure, 17 juli 2026. Onafhankelijke, kritische technische analyse (geschreven bij draftversie 0.5.2) over het risico dat editor-lock-in verschuift naar host-lock-in, en over het ontbreken van onafhankelijke serverimplementaties, zelf geopend.
- Project Impact, GitHub Copilot agent mode: Copilot wordt de standaard-harness, en Claude kan zomaar uitvallen. Eigen eerdere gids over het achterliggende mechanisme uit de grootste valkuil van dit artikel.
Veelgestelde vragen
Wat is het Agent Host Protocol (AHP) in VS Code?
Het Agent Host Protocol is een open, MIT-gelicenseerde standaard die Microsoft op 28 oktober 2026 publiceerde met VS Code 1.144. Het regelt hoe een client (een UI of app) praat met een "Agent Host": het losse proces dat AI-coding-agentsessies zoals Copilot, Claude Code en Codex draait. AHP zelf bepaalt niet hoe die agents redeneren of welke tools ze gebruiken, alleen hoe een client de sessie volgt en bestuurt. Bron: VS Code-documentatie, 18 november 2026 geraadpleegd.
Is het Agent Host Protocol hetzelfde als MCP?
Nee. MCP (Model Context Protocol) standaardiseert hoe een agent tools en databronnen aanroept, zoals een database doorzoeken of een ticket aanmaken. AHP standaardiseert een andere laag: hoe een client de agentsessie zelf volgt en bestuurt, los van welke tools die agent binnen de sessie gebruikt. Een Copilot-sessie kan dus MCP-servers aanroepen voor zijn tools, terwijl die sessie via AHP in meerdere clients tegelijk te volgen is.
Werkt Claude Code nog naast GitHub Copilot in VS Code na deze update?
Standaard wel, maar met een voorbehoud. Zet jouw organisatie Copilot's beheerde instellingen (zoals een sandbox- of permissiebeleid) aan, dan schakelt VS Code de Claude- en Codex-harnessen automatisch uit, tenzij een beheerder dat expliciet toestaat. Dat mechanisme bestond al vóór AHP een eigen naam kreeg en staat los van het protocol zelf. Check dit zelf door in elke harness een testsessie te starten voordat je een nieuw beleid uitrolt.
Is het Agent Host Protocol open source?
Ja. De specificatie en de officiële clientbibliotheken staan onder MIT-licentie in een publieke GitHub-repository van Microsoft, met clients in zes talen (TypeScript, Rust, Kotlin, Go, Swift, .NET). Er bestaan ook al onafhankelijke, niet door Microsoft gebouwde clients en hosts die van die open specificatie gebruikmaken.
Wat is de Copilot Agent SDK en heeft dat met AHP te maken?
De Copilot Agent SDK is de onderliggende basis van de Copilot-harness zelf: die zorgt dat Copilots gedrag consistent is tussen VS Code, de Copilot CLI en de Copilot-app. Het Agent Host Protocol is daar een laag boven: het regelt hoe een client bij een sessie komt die op die SDK (of op de Claude- of Codex-harness) draait, niet hoe de SDK zelf werkt.




