🤖 AI

Persistent Computational State: A Session-Centric Runtime for Generative World Models

Dit artikel betoogt dat het falen van huidige generatieve wereldmodellen om stateful simulatietaken te ondersteunen niet voortkomt uit architecturale beperkingen, maar uit request-centrische runtime-ontwerpen die persistente computationele staat verwerpen, en stelt in plaats daarvan een sessie-centrische runtime voor die een bijna onmiddellijke checkpointing en herstel van niet-recomputabele staat mogelijk maakt om efficiënte, byte-identieke wereldmodel-rollouts te faciliteren.

Oorspronkelijke auteurs: Zhen Lin

Gepubliceerd 2026-07-27

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Zhen Lin

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een videogame bouwt waarin de wereld niet alleen een script afspeelt, maar echt leeft. In een dergelijke game, als je wegloopt van een kampvuur, blijft het vuur branden. Als je een bal laat rollen over een heuvel, blijft hij rollen. Dit is de droom van "generatieve wereldmodellen": AI-systemen die een consistente, levende realiteit kunnen simuleren, en niet alleen mooie plaatjes genereren. Maar hier zit de crux: om deze wereld levend te houden, moet de computer zich exact herinneren wat er is gebeurd, tot in de kleinste details, zelfs wanneer de speler wegkijkt en later weer terugkijkt.

Lange tijd dachten wetenschappers dat deze AI-modellen faalden omdat ze "vergetelijk" waren of "slecht in onthouden". Ze namen aan dat het brein van de AI simpelweg niet groot genoeg was om het hele verhaal vast te houden. Maar dit artikel stelt een andere vraag: wat als de AI niet het probleem is? Wat als het probleem het computersysteem is dat de game draait, dat de aantekeningen van de AI telkens weggooit wanneer de speler een pauze neemt? De auteurs ontdekten dat het "geheugen" dat de AI nodig heeft om de wereld consistent te houden, geen magische superkracht is; het is gewoon een paar specifieke stukjes data die het computersysteem per ongeluk heeft verwijderd.

Het Grote "Ben je het Vergeten?" Mysterie

In de wereld van AI-videogeneratie is er een frustrerende glitch. Je vertelt de AI om een kat te laten springen op een bed, dan vraag je het om de kat weg te laten lopen. Daarna vraag je het om de kat weer terug te laten springen op het bed. In een perfecte wereld zou de kat precies op dezelfde plek landen, met hetzelfde warrige haar. Maar in 2026, toen onderzoekers dit testten met 14 verschillende modellen (met een test genaamd MBench) en 23 verschillende modellen (met WRBench), vonden ze hetzelfde droevige resultaat: de kat kwam niet goed terug. De wereld was "gedrift". Het bed zag er anders uit, de positie van de kat klopte niet en de natuurkunde voelde gebroken aan.

De experts keken naar deze kapotte werelden en zeiden: "De AI-modellen zijn te zwak. Ze hebben nieuwe training nodig, grotere breinen en speciale geheugenmodules om te leren onthouden." Ze dachten dat het probleem in het brein van het model zat.

Maar de auteurs van dit artikel, onder leiding van Zhen Lin, besloten een detective te spelen. Ze vermoedden dat de schuldige niet het brein van de AI was, maar het computersysteem dat de AI draait — de "runtime".

Het Experiment van de Detective: De "Tijdreis"-test

Om hun theorie te bewijzen, zetten de onderzoekers een slim experiment op. Ze namen een werkend AI-model en lieten het een scène genereren. Vervolgens, vlak voordat de scène ingewikkeld werd, maakten ze een "snapshot" van twee zeer specifieke dingen die de computer vasthield:

Het laatste plaatje dat de AI zag (opgeslagen als een eenvoudige lijst met getallen).
De "Random Number Generator" (RNG) staat. Denk hierbij aan de interne dobbelsteenworp van de AI. Elke keer dat de AI een beslissing neemt of een nieuw detail creëert, werpt hij een digitale dobbelsteen. Als je niet precies opslaat op welk getal de dobbelsteen is gevallen, zal de volgende worp anders zijn, en zal de wereld veranderen.

Na het maken van deze snapshot dwongen de onderzoekers de AI om op een "reis" te gaan. Ze lieten het een lange, wilde sequentie van gebeurtenissen genereren — genoeg om elke "impliciete" geheugenfunctie die de AI probeerde vast te houden, volledig te verwarren. Daarna stopten ze de reis, gooiden ze alles weg wat de computer op dat moment vasthield, en herstelden ze de snapshot.

Het resultaat was schokkend. Toen de AI verderging vanaf de snapshot, was de gegenereerde video byte voor byte identiek aan een video waarbij de AI nooit vertrokken was. Het was perfect. De kat landde op exact dezelfde plek. De pixels waren identiek.

Dit bewees dat de AI alles perfect kon onthouden. Het probleem was niet dat de AI vergeetachtig was; het probleem was dat het computersysteem dat de AI draaide, de aantekeningen (de snapshot) had weggegooid voordat de AI ze kon gebruiken.

De "Request" vs. "Session" Verwarring

Waarom gooide de computer de aantekeningen weg? Het bleek dat de computer regels volgde die ontworpen zijn voor chatbots (zoals de systemen waarmee je praat voor je huiswerk). Chatbots werken in "requests" (verzoeken). Je stelt een vraag, de computer geeft antwoord, en daarna ruimt de computer zijn bureau op om klaar te zijn voor de volgende persoon. Dit werkt prima voor chatbots, want als de computer de context vergeet, kan hij simpelweg je vorige woorden opnieuw lezen om het te begrijpen.

Maar wereldmodellen zijn anders. Ze werken in "sessions" (sessies). Een sessie is een doorlopend verhaal. Als je een verhaal pauzeert en later terugkomt, wil je niet dat de computer het boek opnieuw leest; je wilt dat hij precies oppakt waar hij gebleven was.

De auteurs noemen het ontbrekende stukje data de Persistent Computational State (PCS). Dit is de kleine, essentiële lijst met zaken die moeten worden opgeslagen om de wereld consistent te houden.

Voor een eenvoudig model is PCS slechts het laatste plaatje en de dobbelsteenworp (ongeveer 1,38 MB).
Voor een complexer model met een "geheugenbank", is het die bank plus de dobbelsteenworp (ongeveer 185 KB).
Voor een model dat een "venster" van eerdere data gebruikt, is het dat venster plus de dobbelsteenworp (ongeveer 1,67 GB).

Het artikel laat zien dat je niet alles hoeft op te slaan (wat enorm groot en traag zou zijn). Je hoeft alleen de PCS op te slaan. En het beste eraan? Het opslaan en herstellen van deze data duurt slechts 0,012 milliseconden. Dat is vijf grootheden sneller dan de tijd die nodig is om één stap van de video te genereren (1,85 seconden). Het is in feite gratis.

De "Relevance" vs. "Recency" Twist

Het artikel vond ook iets verrassends over hoe je met dit geheugen moet omgaan wanneer de computer vol raakt. Bij chatbots gebruiken computers meestal een "Recency" (recentheid) regel: ze gooien de oudste berichten weg om ruimte te maken voor nieuwe. Maar voor wereldmodellen is dit een ramp.

Stel je voor dat je een film kijkt, en de computer besluit de scène van 10 minuten geleden weg te gooien omdat deze "oud" is, en houdt alleen de scène van 1 minuut geleden over. Als de film vereist dat je je herinnert wat er 10 minuten geleden gebeurde om het einde te begrijpen, dan breekt de film.

De auteurs testten verschillende manieren om het geheugen te beheren. Ze ontdekten dat je voor wereldmodellen een Relevance (relevantie) regel nodig hebt. Je moet de delen van het geheugen bewaren die belangrijk zijn voor de terugkeer (het moment dat de camera terugkomt), zelfs als ze oud zijn.

Wanneer de computer gedwongen werd heel zuinig met geheugen om te gaan (slechts 2 MB beschikbaar), redde de "Recency" regel slechts 6 van de 16 werelden.
De "Relevance" regel redde alle 16 werelden.

Dit is een enorme verschuiving. Het betekent dat je, om een wereld levend te houden, moet stoppen met denken als een chatbot en moet gaan denken als een verhalenverteller die weet welke plotpunten het belangrijkst zijn.

De Belangrijkste Conclusie

Het artikel concludeert dat de "vergeetachtigheid" van AI-wereldmodellen geen bug is in het brein van de AI. Het is een bug in de huishouding van het computersysteem. De AI was klaar om te onthouden; het systeem gooide de aantekeningen simpelweg in de prullenbak.

Door het systeem aan te passen om de "Persistent Computational State" (de snapshot en de dobbelsteenworp) op te slaan en door een slimmere manier te gebruiken om te beslissen wat te bewaren wanneer het geheugen krap is, lieten de onderzoekers zien dat:

De wereld perfect kan worden hersteld. De AI kan terugkeren naar een staat die exact gelijk is aan de staat van daarvoor, zelfs na een lange reis.
Het bijna niets kost. Het opslaan van deze staat duurt microseconden.
Je veel meer sessies kunt draaien. Omdat de computer niet het hele zware geheugen op de supersnelle grafische kaart hoeft te houden, kan hij de "aantekeningen" op de gewone harde schijf opslaan. Dit betekent dat een enkele grafische kaart ongeveer 2.300 keer meer actieve sessies kan afhandelen dan voorheen.

De auteurs hebben niet alleen een manier gevonden om het geheugen te repareren; ze ontdekten dat de "oplossing" eigenlijk een simpele verandering is in hoe we de tijd en ruimte van de computer beheren. De wereld was niet verloren; ze wachtte alleen tot ze opgepakt werd.

Technische Samenvatting: Persistente Computationele Toestand voor Generatieve Wereldmodellen

1. Probleemstelling

Tegen medio 2026 hebben grootschalige benchmarks (MBench en WRBench) vastgesteld dat generatieve video-wereldmodellen er niet in slagen om consistentie te behouden tijdens "viewpoint excursions" (bijv. wanneer een camera weg beweegt van een scène en later terugkeert). Wanneer een model wordt gevraagd een traject te hervatten na een pauze of een splitsing, voldoet de teruggekeerde scène vaak niet aan de eerdere configuratie, en objecten die uit het zicht verdwenen, keren niet consistent terug.

De heersende diagnose in het veld schrijft dit falen toe aan het model zelf, waarbij wordt gesuggereled dat huidige architecturen niet over de noodzakelijke "wat-geheugen" beschikken om verborgen veranderingen vast te leggen of dat trainingsdoelstellingen falen in het superviseren van endpoint-persistentie. Gevolgelijkally omvatten de voorgestelde oplossingen dure architecturale wijzigingen, nieuwe geheugenmodules en grootschalige hertraining.

De Tegen-diagnose van het Papier:
Dit papier betoogt dat voor een significante klasse van modellen de diagnose incompleet en vaak onjuist is. Het falen is niet een gebrek aan capaciteit binnen het model, maar een runtime-fout: de serving-laag verwerpt de niet-recomputabele toestand die vereist is om de wereld voort te zetten. Moderne generatieve serving is "request-centric", waarbij de toestand bij de grenzen van een request wordt teruggevorderd op basis van de aanname (overgenomen van LLM-serving) dat alle nuttige toestand recomputabel is. Deze aanname is onjuist voor wereldmodellen omdat hun toestand een niet-recomputabele kern bevat (bijv. de Random Number Generator-stream of recurrente geheugenactivaties) die niet gereconstrueerd kan worden door inputs opnieuw uit te voeren. Wanneer deze toestand wordt weggegooid, gaat de wereld verloren, niet omdat het model het niet kan genereren, maar omdat de runtime de zaadwaarde (seed) heeft weggegooid.

2. Methodologie en Kernabstractie

Het Herstel-experiment

De auteurs voeren een constructief experiment uit om de "model-tekortkoming"-hypothese te weerleggen. Ze nemen een wereldmodel, genereren een rollout, en maken een snapshot van specifieke runtime-objecten (observatie, RNG-toestand, of geheugenbanken). Vervolgens drijven ze het model door een echte excursie (waardoor impliciete continuïteit wordt vernietigd), herstellen de snapshot, en gaan verder.

Resultaat: De voortzetting is byte-identiek aan een traject dat nooit vertrokken is (DINOv2 gelijkenis 1.0, pixel-fout 0.0).
Ablatie: Het verwijderen van de RNG uit de snapshot verslechtert het resultaat, wat bewijst dat de snapshot "dragend" is en niet genegeerd wordt.
Conclusie: De capaciteit was aanwezig; de runtime heeft de noodzakelijke toestand weggegooid.

Persistente Computationele Toestand (PCS)

Het papier definieert Persistente Computationele Toestand (PCS) als de minimale set niet-recomputabele toestand die moet overleven over requests heen om semantische continuïteit te garanderen.

Formele Definitie: $PCS(M) = \arg \min_S \{ |S| : D(restore(S), oracle) \le \epsilon \}$ $P C S (M) = ar g min_{S} {∣ S ∣ : D (r es t or e (S), or a c l e) \leq ϵ}$
- Waarbij $S$ een deelverzameling is van de volledige runtime-toestand $H$ , $D$ een semantische afstand-metriek is, en $\epsilon$ een tolerantie (0 voor bit-exactheid).
Eigenschappen:
1. Minimaliteit: Geen enkele strikte deelverzameling volstaat; elk element is dragend.
2. Herstelbaarheid: De complement $H \setminus PCS$ is afleidbaar (recomputabel) en hoeft niet opgeslagen te worden.
3. Model-afhankelijkheid: De compositie van PCS varieert per architectuur (bijv. platte observatie + RNG voor Markoviaanse modellen versus groeiende geheugenbanken voor niet-Markoviaanse modellen).

Het PCS-contract

Het papier specificeert een contract voor een sessie-gecentreerde runtime:

API: checkpoint(s), restore(c), fork(c), delete(c).
Invarianten:
- Round-trip: Herstel levert een toestand op die semantisch equivalent is aan de originele.
- Duurzaamheid: Checkpoints overleven procesdood en grenzen tussen processen.
- Fork-onafhankelijkheid: Afstammende continuaties zijn semantisch onafhankelijk van de ouders.
- Snapshot Volledigheid: De checkpoint legt exact de PCS vast en niets dat afleidbaar is.

Ontdekking door Meting (Fingerprinting)

In plaats van handmatig state-lijsten te ontwerpen, stelt het papier een model-agnostische Fingerprinting Procedure voor:

Noodzakelijkheidstest: Ableren systematisch van runtime-buffers. Als het verwijderen van een buffer de return-consistentie metriek buiten de tolerantie brengt, is het "noodzakelijk".
Voldoendeheidstest: Herstel alleen de noodzakelijke set. Als de metriek binnen de tolerantie valt, is dit de PCS.
Redundantie Fallback: Behandel gecorreleerde buffers via selectie met een gul algoritme (greedy selection).
Deze procedure ontdekt automatisch structureel verschillende PCS-composities (plat, groeiend of vensterachtig) voor verschillende modelklassen zonder architecturale aannames.

Sessie-gecentreerde Runtime

De auteurs bouwen een runtime waarbij de eenheid van serving een sessie is, niet een request.

Architectuur: De GPU houdt één actieve sessie vast; de PCS van alle andere sessies bevindt zich op de host (CPU-geheugen).
Evictiebeleid: In tegenstelling tot LLM's die evictie doen op basis van recentheid (LRU), vereisen wereldmodellen relevantie-gestuurde evictie. Frames die relevant zijn voor de "terugkeer" (het anker) moeten behouden blijven, terwijl recente frames van de excursie kunnen worden verwijderd.
Validatie: Een Return-Consistency Conformance Test wordt gebruikt. In tegen tegenstelling tot bit-exactheid (die op de verkeerde toestand kan passen), verifieert deze test dat de herstelde wereld semantisch consistent is met het anker, waarbij "plausibele maar gedrifte" werelden worden afgewezen.

3. Belangrijkste Resultaten

Experimentele Opstelling

Geëvalueerd op drie verschillende modelklassen met gebruik van een enkele A800 GPU:

Cosmos3-Nano: Markoviaans, actie-geconditioneerde diffusie.
WorldMem: Niet-Markoviaans met een expliciete geheugenbank.
Matrix-Game 2.0: Autoregressieve causale-diffusie met adresseerbare KV-context.

Prestaties en Schaling

Byte-Exact Herstel: Alle drie de modellen bereikten bit-identieke continuaties (of latent-exact voor Matrix-Game) na cross-process herstel, wat de "Runtime-Discard Hypothese" bevestigt.
Kosten: Checkpoint/restore operaties duren ~0,012 ms, wat vijf ordes van grootte sneller is dan een generatiestap (1,85 s). State management verbruikt ~0,00035% van de wall time.
Sessie Schaling:
- Device Geheugen: Blijft constant (~4,7 GB) ongeacht het aantal sessies, omdat slechts één sessie resident is.
- Host Geheugen: Schaalt lineair met het aantal sessies.
- Capaciteit: Een sessie-gecentreerde runtime kan ~2.300× meer resident sessies ondersteunen dan een request-gecentreerde runtime (die de werkset van elke sessie op het device moet houden).
Evictie Efficiëntie: Onder geheugendruk presteert relevantie-gestuurde evictie (het behouden van ankerframes) aanzienlijk beter dan recentie-gebaseerde (LRU) evictie. Bij een krap budget behield de relevantie-gebaseerde retentie 16/16 werelden, terwijl LRU slechts 6/16 behield.
Planner Workloads: In een Monte-Carlo Tree Search (MCTS) planner scenario veroorzaakte recentie-gebaseerde evictie het instorten van de zoekboom (het verlaten van forks), terwijl relevantie-gebaseerde evictie de zoekopdracht liet voltooien met nul verloren returns.

Wat Niet Werkte

Predictieve Evictie: Het vervroegd verkleinen van sessies (voordat geheugenlimieten worden bereikt) bleek consequent slechter te zijn dan reactieve evictie, omdat het sessies te vroeg naar hun retentie-vloer duwt, wat later leidt tot meer uitval.
Predictieve Toelating: Het weigeren van sessies op basis van geprojecteerde vraag was schadelijk, omdat het werelden weigerde die succesvol zouden zijn voltooid onder de reactieve baseline.

4. Betekenis en Claims

Het papier claimt dat het "verlies van de wereld" in generatieve modellen vaak een serving gap is, en geen model gap.

Paradigmaverschuiving: Het pleit voor het verschuiven van de eenheid van serving van "request" naar "sessie" en het introduceren van Persistente Computationele Toestand (PCS) als een primitief.
Meetbaarheid: Het demonstreert dat de minimale toestand vereist voor persistentie ontdekt kan worden door meting in plaats van aangenomen of handmatig ontworpen te worden.
Correctheid vs. Efficiëntie: Het benadrukt dat de standaard LLM-serving aannames (recomputabiliteit) onjuist zijn voor wereldmodellen. Een runtime die vertrouwt op recompute-caching voor wereldmodellen geeft een "plausibele" maar foutieve wereld terug, terwijl een sessie-gecentreerde runtime met PCS de exacte wereld teruggeeft.
Bescheidenheid: De auteurs verklaren expliciet dat zij geen universaliteit claimen voor alle architecturen (bijv. recurrente latente-toestand modellen werden niet getest) en dat de "exactheid" resultaten specifiek zijn voor modellen waar de observatie of geheugenbank de zichtbare toestand volledig vangt. Ze verduidelijken ook dat hun bijdrage de abstractie en de serving-laag is, en niet de modelarchitectuur zelf.

De kernconclusie is dat het behouden van de wereld een serving primitief is die microseconden kost, en dat het falen daarvan een gevolg is van het weggooien van niet-recomputabele toestand, niet van een gebrek aan modelcapaciteit.