Nieuws

Agent Host Protocol: wat het wel en niet oplost voor Copilot, Claude Code en Codex

Microsoft publiceerde op 28 oktober 2026, met VS Code 1.144, versie 1.0 van het Agent Host Protocol: een open, MIT-gelicenseerde standaard waarmee elke client met een AI-coding-agent kan praten, ongeacht of die agent Copilot, Claude Code of Codex heet. Met een echt gedraaid voorbeeld van wat een AI-model ervan bakt zonder de documentatie te lezen, en de beslisregel voor wanneer dit al iets voor jouw team verandert.

Dennis ClaassenDennis Claassen17 min lezen
Agent Host Protocol: meerdere schermen die dezelfde AI-agentsessie synchroon volgen

Een agent voor jullie eigen proces?

Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.

Dennis Claassen

Dennis Claassen

AI-trainer · 35+ teams getraind

Bekijk de Agent Sprint

Key takeaways

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:

  1. De hoofdklasse heet AhpClient, niet AgentHostClient. Een verzonnen naam die klinkt als iets wat zou kunnen bestaan.
  2. De client zit niet in het hoofdpakket. Het pakket @microsoft/agent-host-protocol zonder subpad geeft alleen types en reducers, zonder I/O. De echte client komt uit het subpad @microsoft/agent-host-protocol/client.
  3. Je kunt geen {url, token} rechtstreeks aan de client geven. AhpClient is transport-onafhankelijk: je bouwt zelf een WebSocketTransport (uit het subpad /ws) en geeft die apart mee.
  4. Het actietype chat/messageAppended bestaat niet. De echte conventie volgt wel hetzelfde patroon (domein/actie), maar in de officiële actietabel van AHP heet de binnenkomende tekst van een agent chat/delta (een streamend tekstfragment) en chat/responsePart (een nieuw onderdeel van het antwoord), nooit chat/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 geldtDanWaarom die drempel daar ligt
Je team gebruikt alleen Copilot, in alleen VS CodeNiets te doenAHP 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 CodeCheck vóór je een sandbox- of permissiebeleid aanzet of dat beleid Claude/Codex blokkeertDit 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 agentEé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 AHPGeef de officiële clientdocumentatie altijd mee in de promptOns 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 CodeNiets te doenAHP 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:

Wat het Agent Host Protocol niet oplost

Doe dit deze week

  1. 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.

  2. Vraag de AHP-endpoints van je eigen editor op

    Draai code agent endpoints in 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 zoals ahpw, daarop aan te sluiten.

  3. 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.

Bekijk trainingen

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

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.

Tags
github-copilotclaude-codevs-codeai-agentsdeveloper-toolsmcp
Dennis Claassen

Geschreven door

Dennis Claassen

Oprichter en AI-trainer

Dennis is de oprichter van Project Impact en traint Nederlandse bedrijven in het effectief gebruiken van AI. Met jarenlange ervaring in tech en onderwijs helpt hij teams om AI praktisch toe te passen.

Meer over Dennis
Verder lezen

Gerelateerde artikelen.

Meer artikelen over dit onderwerp.

Microsoft Agent 365 spoort schaduw AI-agents zoals Claude Code op in het bedrijfsnetwerk
Nieuws

Schaduw AI-agents: zo ontdekt Microsoft of je team Claude Code gebruikt

Microsoft kondigde op 17 november 2026 aan dat Agent 365 nu 60 soorten lokale AI-agents herkent, waaronder Claude Code, OpenAI Codex en GitHub Copilot, ook als niemand ze ooit heeft aangemeld. Elke gevonden agent krijgt een eigen identiteit in Microsoft Entra. Met de grootste valkuil (verbieden in plaats van reguleren), een beslisregel voor wanneer je ingrijpt, en een geconstrueerd voorbeeld van hoe een te harde regel averechts werkt.

17 min lezen
Kantoormedewerker en een digitale agent die samen aan hetzelfde document werken op een scherm
Nieuws

Copilot Notebooks wordt Copilot Workspaces: wat werkt al, wat nog niet

Op Microsoft Ignite 2026 kondigde Microsoft aan dat Copilot Notebooks wordt opgevolgd door Copilot Workspaces, een gedeelde ruimte waarin mensen en agents samen aan een document werken. Home en Office in Copilot zijn sindsdien algemeen beschikbaar. Workspaces en Autopilot niet: die draaien nog alleen in het Frontier-programma, en Autopilot is bij de start zelfs alleen voor klanten in de Verenigde Staten. Wat dat concreet betekent voor een Nederlands team, en wat je deze week al wel kunt doen.

17 min lezen
Agent 365 Business Analytics: Microsofts nieuwe dashboard om te zien wat AI-agents per taak kosten
Nieuws

Agent 365 Business Analytics: grip op wat je AI-agents echt kosten

Microsoft kondigde op 17 november 2026, tijdens Microsoft Ignite, Agent 365 Business Analytics en Agent 365 Cost Management aan: een nieuwe laag die moet laten zien wat je AI-agents kosten, voor wie, en of dat zijn geld waard is. Met een echt gedraaid voorbeeld van een kostenbeleid dat op het eerste gezicht klopt maar een typische denkfout bevat, en de beslisregel voor wanneer je dit al nodig hebt.

16 min lezen

Een agent voor jullie eigen proces?

Kies een afgebakende taak en werk toe naar een agent met heldere bronnen, rechten en controle.

Bekijk de Agent Sprint