Week W41 · 5-11 oktober 2026

Build AI. Run AI. Own AI.

Ik bouw dit niet in een lab, maar middenin mijn eigen leven als zzp'er en vader — en toch ontwerp ik elke keuze alsof er een enterprise-klant op leunt: multi-tenant vanaf dag 1, secrets die nooit een mens ziet, migraties die nooit terug kunnen. Dit is het logboek van die combinatie: zelf bouwen, zelf draaiend houden, zelf eigenaar blijven — inclusief de aanname, de misser en de prijs van elke keuze.

Aan het eind van vorige week (W40) zag ik tijdens een losse test hoe bedrieglijk een groene technische status kan zijn. Deze week dook ik met een strikt read-only diagnose in mijn eigen productieomgeving om te kijken hoe de kennisgraaf-verwerking er onder de motorkap echt bij stond. Wat ik aantrof was geen losse bug, maar een systeemles over hoe je de voortgang van achtergrondwerk bewaakt: 176 bron-runs stonden in de database nog op `running`, terwijl hun onderliggende jobs al lang klaar of gestopt waren.

Het probleem dat opdook

Wanneer ik een nieuw document of een reeks notities aanbied aan de kennisgraaf, start het platform een source run die het werk opdeelt in kleinere taken in de wachtrij (`pa_job_queue`): relevantie bepalen, claims extraheren per dimensie, embeddings berekenen en bewijs valideren.

Toen ik in productie keek waarom sommige documenten eeuwig op "bezig met verwerken" bleven hangen, zag ik drie dingen die samen een stille file veroorzaakten:

  1. Geen harde eindafrekening als de laatste job buiten het normale pad eindigde. Als alle jobs van een run netjes één voor één via het gelukkige pad klaar kwamen, zette de laatste job de bovenliggende run op `completed`. Maar als een job na een retry uitviel, werd overgeslagen of in een randgeval eindigde zonder de sluitsteen aan te roepen, bleef de bovenliggende run tot in de eeuwigheid op `running` staan — terwijl er in de wachtrij geen enkele actieve taak meer voor die bron bestond.
  2. *Grote bronnen verdrongen kleine bronnen in de wachtrij (queue starvation). Een enkel zwaar document dat tientallen dimensie-jobs tegelijk in de rij zette, kon alle werkers minutenlang bezet houden, waardoor een simpele korte notitie achteraan in de file moest wachten.
  3. Tijdgevoeligheid in profielantwoorden. In dezelfde inspectieronde rond mijn publieke profielchat zag ik dat feiten uit een opdracht van drie jaar geleden zonder tijdsankers soms net zo tegenwoordig klonken als mijn huidige rol.

De makkelijke weg die ik had kunnen nemen

Ik had met één handmatige SQL-update die 176 zwevende runs op `completed` of `failed` kunnen zetten en een simpel cron-scriptje kunnen draaien dat elke nacht alles ouder dan een uur opruimt. Dat veegt het dashboard schoon, maar laat de ontwerpfout zitten: de volgende keer dat een job buiten de happy flow eindigt, liegt de status opnieuw.

De keuze die ik maakte en de strategie erachter

Ik trok de levenscyclus van de run (het functionele verwerkingsdossier) en de queue (de losse achtergrondtaken) scherp uit elkaar:

  • Een onvoorwaardelijke finalize-invariant. Een bron-run mag nooit meer afhankelijk zijn van de vraag of één specifieke laatste job toevallig het licht uitdoet. Ik bouwde een deterministische afsluit- en reconciliatiestap die controleert of er voor een run nog openstaande of draaiende jobs bestaan, en op basis van de daadwerkelijke uitkomsten van alle deelstappen de eindstatus bepaalt (`completed`, `partial` of `failed`).
  • Eerlijke verdeling in de wachtrij (fairness & anti-starvation). De job-queue pakt taken niet langer blind op volgorde van binnenkomst per bulk-bron, maar verdeelt de capaciteit eerlijk over actieve bronnen en tenants. Zo blokkeert één zware achtergrondanalyse nooit meer het directe werk dat erna binnenkomt.
  • Een temporele vertrouwenslaag in de profielchat. Feiten en rollen krijgen bij het ophalen expliciete tijdsankers mee (wat is actueel, wat is afgerond verleden), zodat de assistent het verschil kent tussen "ik doe dit nu" en "ik heb dit in 2023 gedaan"*.
Architectuurdiagram W41: Scheiding tussen Source Run status en Job Queue lifecycle met deterministische finalize-invariant en wachtrij-eerlijkheid

Wat het kostte

Het scheiden van run-status en job-status vroeg om een grondige herziening van hoe fouten en deelresultaten worden opgeteld. Want wanneer is een run met twaalf dimensies eigenlijk geslaagd als er elf slagen en één faalt? Door die vraag expliciet te beantwoorden in code in plaats van hem over te laten aan het toeval van de laatste worker, werd het toestandsmodel een stuk eerlijker.

Wat het nu oplevert en wat ik ervan leerde

De 176 zwevende runs zijn netjes afgewikkeld, nieuwe runs kunnen niet meer stilletjes in `running` blijven hangen als hun jobs klaar zijn, en de wachtrij blijft responsief tijdens zware analyses.

De les van deze week sluit naadloos aan op die van vorige week: een statusveld waaraan geen harde eindvoorwaarde hangt, verandert vroeg of laat in een leugen. Maar zelfs als een job netjes afrondt en het taalmodel met HTTP 200 antwoordt, ben je er nog niet — want een week later ontdekte ik wat er gebeurt als een model midden in een geldig lijkende aanroep tegen zijn tokenlimiet aanloopt.