Een blijvend lerende runtime voor AI-agents.
MS Duplex definieert een nieuwe categorie.
MS Duplex maakt van een tijdelijke assistent, gebonden aan één model, een systeem dat leert van het werk, zijn context behoudt, jouw regels handhaaft, beter wordt met je tools, wat het leert met toestemming deelt en van modelaanbieder wisselt zonder het geleerde te verliezen: het Agent Operating System, aangedreven door runtime-intelligentie.




De laag die alles verenigt.
De AI van vandaag verdeelt intelligentie over drie lagen: het model redeneert, retrieval levert documenten en herinneringen, en applicatiecode regelt workflows, rechten en tools. Geen van drieën leert van het werk. MS Duplex verenigt ze tot één systeem dat leert van alles wat je agents doen, en dat bewaart zolang je MS Duplex draait.
Het model redeneert over de taak, en vergeet die zodra de taak klaar is.


Waarom MS Duplex een Agent Operating System is.
MS Duplex is het Agent Operating System, aangedreven door runtime-intelligentie: de laag waarop elke agent draait, welk model die ook gebruikt. Het coördineert alles wat een doel nodig heeft: het plan, de opties, de beslissing, je goedkeuringen, het werk in je tools en de controle van het resultaat. Het draagt de context van elke agent mee, houdt langlopend werk gaande door pauzes en wijzigingen heen, houdt één geschiedenis van elke stap bij en leert van wat is geverifieerd.
Agents zijn langlopende software geworden.
Een agent werkt nu uren of dagen, over sessies, apps en mensen heen. Werk dat zo lang loopt, heeft context, regels en een vastlegging nodig die één sessie overleven.
Elke agent bouwt dezelfde laag opnieuw.
Zonder MS Duplex zitten geheugen, regels, toolkoppelingen en vastleggingen in de eigen code van elke agent. Niets daarvan leert, en alles begint opnieuw zodra het model, de client of de leverancier verandert.
MS Duplex maakt daar een eind aan, met één laag onder ze allemaal.
Het model gaat veranderen.
Een nieuwe versie, een nieuwe leverancier: het model onder een agent gaat veranderen. MS Duplex bewaart wat je agents hebben geleerd, zodat het model eronder kan wisselen en het werk doorloopt.
01 · Eén laag
MS Duplex — het Agent Operating System, aangedreven door runtime-intelligentie.
Elke agent draait erop, welk model die ook gebruikt. Huur het model. Bezit de intelligentie.
Wat MS Duplex elke agent geeft, welk model die ook gebruikt.
- Context
Context die de sessie overleeft
Het doel, de beslissingen en het onafgemaakte werk gaan mee naar de volgende sessie, agent of het volgende model.
- Regels
Regels vóór elke actie
Elke modelaanroep en elke toolactie wordt vóór uitvoering aan jouw regels getoetst, en de acties die je kiest, wachten op het akkoord van een mens.
- Langdurig werk
Langdurig werk dat doorloopt
Werk dat dagen, sessies en agents beslaat, blijft één klus, met elke stap vastgelegd en een gecontroleerde afronding.
- Je stack
Je stack, één gereedschapskist
Je retrieval, caches, kennisgrafen, API’s en modellen worden één gereedschapskist voor elke agent, en toestemming blijft bij jouw controles.
- Niveaus
Elk niveau gescheiden
Wat een persoon, een team en de organisatie leren, blijft in de eigen laag, en elke klant blijft gescheiden.
- Historie
Één historie
Elke stap laat een ontvangstbewijs achter, in één geschiedenis die je kunt nagaan en exporteren.
- Elk model
Modellen die je kunt wisselen
Wissel van model, client of leverancier, en wat je agents hebben geleerd, blijft.
- Aangedreven door runtime-intelligentie
Elk doel, gecoördineerd
Het plant, simuleert en beslist elke stap binnen jouw regels, handelt via je tools, controleert het resultaat en leert van wat is geverifieerd, zodat elke agent die erop draait het werk gedaan krijgt en beter wordt met gebruik.


Wat retrieval nooit is ontworpen om te bewaren.
Retrieval haalt documenten en herinneringen terug die relevant lijken. MS Duplex bewaart de lessen uit het werk, en handelt ernaar:
- 01Wat slaagde, en wat mislukte
- 02Welke acties tot welke resultaten leidden
- 03Welke tool in welke situatie werkt
- 04Welke werkwijzen de resultaten verbeterden
- 05De voorkeuren en regels die nog gelden
- 06Wat elke actie verandert
- 07De skills die het uit herhaald werk heeft geleerd
- 08Wat moet worden vergeten, teruggedraaid of ingetrokken
- 09Wanneer het zelf kan antwoorden, en wanneer het je model moet vragen


Je AI is het model, plus wat MS Duplex heeft geleerd.
Het model kan wisselen. Wat MS Duplex leerde, plande, simuleerde en besliste, blijft.
Je AI
Waarmee je mensen en agents werken
Het basismodel
Kan wisselen: een nieuwe versie, een nieuwe leverancier
Wat MS Duplex heeft geleerd
Blijft: van jou, en groeit door
Die scheiding verandert wat een organisatie bezit. Wat ze heeft geleerd, hoeft niet langer in de gewichten van één leverancier te zitten, in één chattranscript of in het eigen geheugenformaat van één app.
Er komt een nieuw model. Zonder MS Duplex begint het vanaf nul; met MS Duplex behoudt het alles wat tot nu toe is geleerd.


Voor bedrijven: AI die aangroeit.
MS Duplex verandert de economie van AI op het werk. Elk bevestigd resultaat kan de volgende taak beter maken, en wat zich opbouwt, blijft van jou.
Waarde die aangroeit.
De meeste AI-implementaties beginnen bij elke taak bijna vanaf nul. Prompts, retrieval en vaste workflows geven context, maar het systeem wordt niet beter van elk bevestigd resultaat. Met MS Duplex kan elke afgeronde taak iets achterlaten:
- Een betere toolkeuze
- Een les over wat een actie verandert
- Een herbruikbare skill
- Een gecorrigeerde beslissing
- Een regel om te onthouden
- Een uitgewerkt voorbeeld
- Een duidelijk signaal van wat werkte
- Een snellere weg terug in het werk
- Een nieuwe mogelijkheid, getest vóór gebruik
Zo wordt het systeem nuttiger naarmate je organisatie het meer gebruikt.
Intelligentie die met je meegaat.
Claude, Codex, Cursor en Hermes kunnen allemaal putten uit dezelfde MS Duplex, en via MCP + hooks kunnen je eigen agents dat ook. Wissel van model, agentclient, modelaanbieder of toolleverancier, en je behoudt de processen, regels, geschiedenis en skills die je organisatie heeft geleerd.
De afhankelijkheid van één leverancier valt weg, en wat je organisatie leert, wordt blijvend kapitaal.
Persoon, team en bedrijf, in lagen.
MS Duplex bewaart wat het leert op elk niveau dat ertoe doet:
- Één persoon
- Een team
- De organisatie
- Één taak
- Een werkruimte
- Een agent
- Een gedeelde draad
Een persoon behoudt de eigen voorkeuren en werkwijzen. Een team bouwt een gedeelde aanpak en kennis van tools op. De organisatie stelt de regels waarbinnen iedereen werkt, terwijl mensen en teams daaronder blijven leren. Dat is veel meer waard dan één globaal geheugen.
Regels voor wat agents doen, niet alleen voor wat ze te horen krijgen.
Regels in MS Duplex bepalen wat een agent echt uitvoert, niet alleen wat een prompt van het model vraagt. Via MCP + hooks doet MS Duplex mee vóór elk verzoek, vóór elke toolaanroep en na elk resultaat, en telkens als er kennis wordt gedeeld of vergeten.
Ondernemingen hebben controle over gedrag nodig, geen betere formuleringen.
Fine-tuning, voor veel minder dingen.
Fine-tuning blijft belangrijk als een model een nieuw algemeen vermogen of nieuw gedrag nodig heeft. Maar voor veel zakelijke behoeften hoeven de gewichten helemaal niet te veranderen:
- “Onthoud onze releaseprocedure.”
- “Leer welke diagnosetool deze storing oplost.”
- “Stop met aanraden wat steeds mislukt.”
- “Houd je aan de randvoorwaarde van deze klant.”
- “Ga verder met de taak nadat we van model wisselen.”
- “Deel dit bewezen proces met het team.”
- “Trek in wat niet meer klopt.”
MS Duplex regelt dit allemaal buiten het model: sneller, omkeerbaar, herleidbaar tot de bron, en meestal goedkoper dan telkens opnieuw fine-tunen.
Een nieuwe slotgracht.
Het waardevolle bezit is niet langer alleen het model. Het blijvende voordeel wordt dit:
De operationele intelligentie van je organisatie: continu opgebouwd, onder toezicht en overdraagbaar.
Twee bedrijven kunnen hetzelfde model gebruiken en heel verschillende resultaten krijgen, omdat het ene jaren aan bevestigde lessen, skills, regels, correcties, uitkomsten en taakgeschiedenis in MS Duplex heeft.


Voor onderzoek: continu leren, als systeem.
MS Duplex behandelt continu leren als een systeemvraagstuk, niet alleen als de vraag hoe je de gewichten van een netwerk bijwerkt.
Leren dat de gewichten met rust laat.
Veel onderzoek naar continu leren werkt de gewichten van een netwerk bij en probeert daarbij catastrofaal vergeten te vermijden. MS Duplex kiest een andere weg, en past zich aan buiten de gewichten van het model. Het is nog steeds echt continu leren: wat het hierna doet, verandert met wat het heeft meegemaakt. En het biedt wat met het bijwerken van gewichten moeilijk lukt:
- Exacte toeschrijving
- Leren dat terug te draaien is
- Scheiding tussen klanten
- Selectief vergeten
- Een volledige audittrail
- Aanpassing ter plekke
- Veel minder rekenkracht
- Geen downtime door hertraining
Veel manieren van leren, die als één draaien.
MS Duplex brengt verschillende soorten leren samen: snel aanpassen, herkennen wat nieuw is, weten hoe zeker het is, voorspellen wat een actie zal veranderen, plannen, leren van uitkomsten, en bewijs omzetten in skills die het vóór gebruik test.
De waarde voor onderzoek zit niet in één afzonderlijk algoritme. Die zit erin dat ze allemaal draaien als één blijvend leersysteem onder toezicht, achter echte agents.
Afleren dat overal doorwerkt.
Vergeten is meer dan een record wissen. Als het bewijs achter iets wordt verwijderd, kan alles wat MS Duplex ervan leerde mee worden ingetrokken. Dat is belangrijk voor privacy, correctie, veiligheid, regelgeving en wetenschappelijke validiteit.
Een systeem dat leert maar niet nauwkeurig kan afleren, is onvolledig voor alles wat jarenlang moet draaien.
Langlopend werk, zonder het hele transcript.
MS Duplex neemt mee wat een lange taak nodig heeft: het doel, de beslissingen, de randvoorwaarden en het werk dat nog openstaat.
Continuïteit hoeft niet te betekenen dat het model de hele geschiedenis opnieuw krijgt, en dat is belangrijk voor agents die uren of dagen werken.
Leren van meer dan woorden.
MS Duplex leert naast tekst ook van beelden, audio, video en documenten, onder hetzelfde toezicht op wat geleerd mag worden. Schermafbeeldingen, ontwerpen, opgenomen gesprekken, documenten en tooluitvoer kunnen het allemaal iets leren.
Het gaat niet om media vinden. Het gaat erom dat bewijs te koppelen aan uitkomsten, taken, skills en vergeten.


Voor het vakgebied: waar intelligentie huist.
De grootste implicatie: intelligentie hoeft niet langer helemaal in het basismodel te zitten.
Een nieuwe eenheid van intelligentie.
De gangbare opvatting, en de opvatting die MS Duplex mogelijk maakt:
Het model is het intelligente product.
Het intelligente product is het model, plus een runtime die blijft leren.
Verbeteringen kunnen zich dan opbouwen tussen modelaanroepen, tussen sessies, en zelfs tussen modelaanbieders.
Modellen worden makkelijker te vervangen.
Als geheugen, personalisatie, regels, geleerd toolgebruik, taakcontinuïteit en de eigen skills van een organisatie in MS Duplex zitten, wordt het model eronder makkelijker te vervangen. Modellen concurreren nog steeds op redeneren, snelheid, modaliteit en prijs.
Maar wat een klant heeft opgebouwd, verdwijnt niet meer als het model wisselt, en de macht verschuift naar wie het geleerde in handen heeft.
Agents die zichzelf blijven.
Een agent die aan MS Duplex gekoppeld is, blijft zichzelf wanneer:
- Een gesprek eindigt
- Het contextvenster volloopt
- De client herstart
- Een taak dagen later wordt hervat
- Het model wisselt
- Het werk van Claude Code naar Codex verhuist
- Een andere bevoegde persoon aansluit
Dat komt dichter bij een vaste digitale medewerker dan bij een reeks losse chats.
Een heldere grens tussen model en systeem.
ACI is de intelligentie die zich aanpast. MS Duplex is het product dat het aan je AI koppelt: de beslissingen, het toezicht, de ingangen en de levenscyclus van alles wat het leert. Agents werken met een paar eenvoudige, stabiele bewerkingen, het model hoeft nooit te weten wat eronder draait, en hooks koppelen elke beslissing aan een echte actie.
Die grens maakt van een motor infrastructuur die elke agent kan gebruiken.
Een andere manier om op te schalen.
Het vakgebied gaat er vaak van uit dat krachtigere AI vooral grotere modellen, meer trainingsdata, langere contextvensters of meer rekenkracht bij inferentie nodig heeft. MS Duplex voegt een andere dimensie toe:
Een krachtig model dat bevestigde ervaring blijft opbouwen, buiten zijn gewichten.
Dat kan meer opleveren, voor minder, dan het model of zijn prompt steeds opnieuw vergroten.


Wat MS Duplex wordt.
MS Duplex zorgt ervoor dat AI-agents onthouden, leren, plannen, simuleren, beslissen, verbeteren, gehoorzamen en doorgaan, over sessies en modellen heen.
Het is niet zomaar
- Een vectordatabase
- Een geheugenplug-in
- Een promptmanager
- Een MCP-server
- Een workflowengine
- Een beleidsgateway
- Een systeem voor fine-tuning
Het brengt onderdelen van ze allemaal samen in één runtime die leert.
MS Duplex naast geheugen, skills, fine-tuning en AI-gateways →

In het kort.
Voor bedrijven
AI die beter wordt door gebruik, en die wat hij leerde behoudt, over agents en modelleveranciers heen.
Voor onderzoek
Continue aanpassing, onzekerheid, geheugen, planning, omkeerbaar leren en bewijs uit elk medium, in één systeem dat achter echte agents werkt.
Voor het vakgebied
Intelligentie hoeft niet langer helemaal in het model te zitten. Wat geleerd wordt, kan een aparte laag worden: onder toezicht, overdraagbaar en van jou.
Infrastructuur, geen losse functie.
De grootste kans is continu leren in de praktijk laten werken: direct, bewaard zolang je het draait, te corrigeren binnen je regels, en via MCP + hooks beschikbaar voor de agents die je al gebruikt, zonder dat je model verandert. MS Duplex is ontworpen als de laag waarin mensen en organisaties hun AI-intelligentie opbouwen, en het Agent Operating System waarop hun agents draaien, terwijl modellen eronder vervangbare redeneermotoren worden.


Bezit de intelligentie die elk model overleeft.
Een pilot zet MS Duplex in op je eigen werk, met vooraf afgesproken succescriteria.