La NASA affirme avoir été la première à appliquer le concept de jumeau numérique (“Digital Twin”). Afin de mieux prédire le comportement des objets qu’elle envoyait dans l’espace, elle avait besoin d’une copie sur Terre – non seulement physique, mais aussi numérique. Certains scénarios sont tout simplement difficiles à reproduire sur Terre, mais doivent pouvoir être simulés de manière aussi détaillée que possible.  Cette approche s’est répandue dans d’autres secteurs, comme l’aéronautique, où des erreurs de conception pourraient avoir des conséquences catastrophiques, ou encore là où une méthode par essais et erreurs serait trop coûteuse ou pratiquement impossible.   

Le jumeau numérique n’est toutefois apparu sur le radar de Gartner qu’à la fin de l’année 2016. La page Wikipédia consacrée à ce sujet est aussi relativement récente, puisqu’elle a été créée en 2015, bien plus tard que celles dédiées à la réalité virtuelle (2001) et à l’Internet des objets (2007). L’idée des jumeaux numériques a toutefois rapidement gagné en popularité, aidée en cela par le programme européen Horizon 2020 qui y a vu un potentiel et a financé divers projets sur ce thème à hauteur de plusieurs millions d’euros ([1], [2], [3], [4]). En Flandre, cette opportunité a été saisie avec empressement, avec l’IMEC dans un rôle central, soutenu par un Digitaal Vlaanderen enthousiaste, sans oublier VITO, qui est également convaincu.

D’un point de vue marketing, le jumeau numérique a donc déjà fait ses preuves. Mais peut-il apporter une valeur ajoutée concrète aux administrations publiques ? Dans ce domaine également, les workflows deviennent rapidement complexes, les modifications peuvent s’avérer coûteuses, et l’on souhaite peut-être pouvoir simuler certaines choses avant de les mettre en œuvre. Dans cet article, nous examinerons ce que le jumeau numérique peut apporter dans un contexte administratif.

Définitions

Il existe de nombreuses interprétations du jumeau numérique. L’essence même du concept n’est en tout cas pas nouvelle : un système est représenté numériquement afin de pouvoir être observé, testé et amélioré sans impact direct sur son fonctionnement réel. La principale caractéristique distinctive est la synchronisation continue (ou du moins régulière) entre le système réel (l’entité cible ou target entity) et son homologue numérique. Le CCR de l’UE adopte un modèle de maturité qui distingue différents niveaux d’intégration ; ce n’est que dans le cas d’un échange bidirectionnel de données entre l’entité cible et le jumeau que l’on parle véritablement de jumeau. À l’échelle internationale, des efforts sont entrepris pour standardiser la terminologie.

Pour être utile, un jumeau numérique doit être développé avec suffisamment de détails. Le niveau de granularité ou de résolution variera en fonction de l’application. Le jumeau doit pouvoir représenter fidèlement l’entité cible tout au long de son cycle de vie, mais cela ne signifie pas que chaque détail doive être simulé dans les moindres détails. Dans le secteur médical, on voit apparaître des jumeaux numériques au niveau de la cellule, de l’organe, d’un individu ou de la population. Rien n’empêche non plus qu’un jumeau numérique ne constitue qu’une partie d’un système plus vaste ; il peut, par exemple, n’être élaboré que pour un seul composant critique.

On distingue deux courants de jumeaux numériques :

• Les jumeaux technologiques de haut niveau (aéronautique, industrie, infrastructure), où le jumeau est utilisé pour le diagnostic, la maintenance prédictive ou la conception itérative sur la base de données opérationnelles – à la NASA, pour la distribution d’électricité…
• Les jumeaux de systèmes d’information ou sociotechniques (villes, organisations, services), dans lesquels l’entité cible n’est pas tant une machine qu’un système complexe impliquant plusieurs parties prenantes, composé de processus, de règles, de personnes et de flux de données. C’est dans ce deuxième courant que s’inscrit le secteur public, mais c’est aussi là que les définitions deviennent floues et que le “jumeau numérique” est parfois utilisé comme terme marketing pour désigner une structure “dashboard + modèle“.

Alors que le flou est peut-être inévitable sur le plan politique, nous souhaitons néanmoins une interprétation plus opérationnelle dans la pratique. Nous pourrions définir un jumeau numérique administratif comme une représentation numérique de la réalité de la prestation de services, continuellement actualisée et testable. Cela inclut les processus, les dossiers et leur état d’avancement, un système applicable des règles en vigueur, ainsi que l’ensemble des flux de données nécessaires au bon fonctionnement de l’ensemble. Cela doit permettre de suivre de près la situation actuelle et de simuler à l’avance les modifications éventuelles avant leur application.

Pour un processus industriel piloté par des données de capteurs et les lois immuables de la physique, cela s’avère plus facile que pour le secteur public, où l’on traite souvent des données sensibles et où l’on dépend de règles changeant régulièrement qui laissent place à l’interprétation (voir également nos articles précédemment publiés sur les Rules As Code). Les préoccupations liées à la gouvernance des données (RGPD, etc.) peuvent compliquer la mise en place d’une synchronisation avec les données en temps réel. La logique décisionnelle est souvent étroitement liée au code des applications, ce qui complique les ajustements et les contrôles de conformité. C’est pourquoi, dans le contexte public, la mise en place d’un Digital Shadow, que l’on peut situer quelque part entre un “bête” modèle et un véritable jumeau synchronisé, constitue souvent déjà un exploit en soi.

Projets phares

En Europe, les projets de jumeaux numériques les plus marquants concernent principalement le climat et la science :

• Destination Earth ou DestinE combine des données à grande échelle provenant de satellites (météorologiques) et de Copernicus dans un data lake. Sur cette base, deux jumeaux numériques ont vu le jour : Climate Change Adaptation (long terme) et Weather-induced Extremes (court terme). Pour ce faire, ils ont développé leur propre Digital Twin Engine. Le projet se poursuit, l’objectif étant de faciliter davantage les “applications en aval” d’utilisateurs externes qui peuvent approfondir certains aspects ou des questions de recherche spécifiques. Tout cela doit être partagé via une plateforme unique coordonnée par l’ESA.
• Le projet EDITO vise à atteindre des objectifs similaires, mais dans le domaine des océans.
  À cette fin, les données d’EMODnet et de Copernicus sont mises en commun. L’accès passe par un Datalab qui propose également une série d’autres modules et services, et les applications qui y sont développées peuvent être hébergées sur la plateforme numérique de l’initiative.
• Plusieurs use cases sont également répertoriés dans le cadre du projet de recherche interTwin, récemment achevé (et financé par l’Union européenne), qui visait à développer une architecture quelque peu standardisée avec des composants réutilisables pour les jumeaux numériques. Ils ont abordé le sujet plutôt sous l’angle du CERN, et indépendamment des deux initiatives mentionnées précédemment. Au fil du temps, ils ont toutefois pris conscience de l’existence les uns des autres et une interopérabilité potentielle avec le projet DestinE, lié à l’ESA, a déjà été étudiée.

Dans un contexte administratif, les données issues de satellites ou d’accélérateurs de particules nous sont moins utiles. En raison des exigences en matière de gouvernance, l’accent est plutôt mis sur une interopérabilité et un échange de données corrects, conformément à tous les cadres juridiques en vigueur. À cet égard, les initiatives européennes les plus utiles sont peut-être encore les Data Spaces – pour un “jumeau politique”, par exemple, le Legal Data Space. Il existe également des points communs avec le concept de Regulatory Sandboxes tel qu’il apparaît notamment dans l’Interoperable Europe Act ou, plus récemment, dans l’AI Act : un jumeau numérique administratif peut remplir le rôle d’un tel bac à sable s’il existe de bons mécanismes de développement et d’évaluation de scénarios.

Use Cases administratifs

Avant de nous lancer dans des secteurs complexes tels que les soins de santé et la sécurité sociale, nous devons tout de même nous demander si les jumeaux numériques peuvent apporter une réelle valeur ajoutée à ce qui existe déjà aujourd’hui – car la hype en soi n’apporte rien.

En matière de modélisation de politiques pour la sécurité sociale, il existe par exemple déjà une base solide avec le modèle de microsimulation EUROMOD, dont la variante belge s’appelle BELMOD. Il s’agit de microsimulations statiques dans lesquelles des données très détaillées sont combinées à des règles codifiées, permettant de simuler des réformes des paramètres de la sécurité sociale (cotisations, allocations…). Ces études sont généralement menées dans les universités. On peut se faire une idée de ce que cela implique via EUROMOD Online.

D’une certaine manière, ce type de modèle s’apparente déjà à un jumeau numérique pour la politique sociale, mais il lui manque encore deux éléments essentiels :

• des liens en temps réel avec les données administratives : cela permettrait de simuler les effets budgétaires et distributifs sur la situation actuelle, plutôt que sur des données obsolètes datant de plusieurs années.
• des informations sur les processus de prestation de services (délais de traitement des dossiers, capacité de traitement…) : cela permettrait également d’évaluer l’impact opérationnel des réformes sur les services exécutifs.

Il ne serait pas du tout simple d’ajouter cela : les données en question sont de nature très sensible. L’utilisation des données réelles comme source de données en temps réel pour les simulations nécessiterait certainement un anonymisation poussée (conformément au RGPD), en plus d’une série d’autres mesures de sécurité. Il s’agit là d’un exercice complexe en soi, qui pourrait également entraîner la perte d’informations utiles.

Le statut d’une personne au sein de la sécurité sociale est en outre déterminé par une succession d’événements susceptibles d’avoir des répercussions à long terme et d’interagir entre eux (emploi, licenciement, maladie, accident, pension, naissance d’un enfant…). Pour être vraiment utile, un jumeau devrait pouvoir modéliser l’ensemble du parcours d’un individu au sein du système. Non seulement le statut individuel, mais aussi celui des dossiers (les délais sont-ils respectés ?) et de l’administration (y a-t-il un retard dans le traitement ?) évoluent au fil du temps.

Si, aujourd’hui, une bonne ombre numérique (digital shadow) d’un service est déjà disponible, l’ajout de données évolutives relatives à la répartition de la charge de travail, aux capacités, à l’avancement des dossiers… permettrait de franchir une nouvelle étape, comme une simulation du flux de dossiers. De telles simulations sélectives peuvent servir à des analyses contrefactuelles (“et si”) qui permettent de mieux évaluer l’impact d’un changement (au niveau organisationnel ou réglementaire). À l’inverse, on peut également y voir un cadre pour des tests de régression : les calculs effectués sur des échantillons représentatifs peuvent être répétés chaque fois qu’un élément change, afin de localiser l’impact le plus important.

L’administration des soins de santé a d’autres priorités : le suivi des patients et des consultations est urgent, l’affectation du personnel et des ressources est un casse-tête de planification complexe, sans parler des divers remboursements et assurances… Pour évoluer vers le jumeau numérique, les European Health Data Spaces pourraient jouer un rôle important, tout comme les nouvelles solutions que l’on s’efforce actuellement de mettre au point pour l’utilisation secondaire des données de santé.

Nous sommes encore loin du rêve des soins de santé optimisés individuellement sur la base d’un jumeau numérique personnel du patient, une idée qui s’accompagne d’ailleurs de nombreux risques non négligeables sur les plans de l’éthique et de la confidentialité. À plus court terme, les possibilités se situent plutôt au niveau de l’organisation. En ajoutant à une ombre numérique existante des données relatives aux admissions, aux listes d’attente, à l’affectation du personnel et à l’activité, il devient possible de mieux absorber les évolutions stratégiques et opérationnelles.

La mise en œuvre: une opération coûteuse?

Pour rester concentrées sur ce qui est possible aujourd’hui ou à court terme, les administrations peuvent s’inspirer des “piles de référence” de composants technologiques, développées dans le cadre de jumeaux numériques existants. Nous en avons déjà mentionné quelques-unes précédemment et ne les répéterons pas ici.

Un jumeau numérique doit pouvoir contenir une représentation de l’état actuel d’un système et traiter les événements qui ont un impact sur celui-ci. À cette fin, dans le cadre des initiatives européennes FIWARE (Future Internet), le groupe de travail Context Information Management au sein de l’ETSI a développé le standard et l’API NSGI-LD.  Il semble toutefois que ce standard ne soit pas encore très répandu en dehors de son propre réseau composé principalement des initiatives Smart City et IoT.

Les systèmes administratifs ne se résument pas à de simples décisions. Les processus impliquent des interactions, des documents et, parfois, une certaine marge d’appréciation. Les standards ouverts issus du business process management s’avèrent ici utiles. DMN (decision modeling), BPMN (business processes) et CMMN (case management) sont complémentaires et permettent de modéliser ces aspects. Des extensions voient également le jour à partir de ces initiatives, comme Constraint DMN (cDMN), développé à la KULeuven, qui permet une logique plus complexe. Nous pouvons alors composer un jumeau numérique à partir d’un moteur de décision DMN qui calcule “ce que disent les règles” (c’est là que l’approche Rules As Code peut éventuellement trouver sa place), enrichi de couches qui prennent en charge les processus et le flux de dossiers (statut, délais, documents de support), et enfin d’une synchronisation régulière pour pouvoir mettre à jour l’état opérationnel (ou le contexte). Cette approche est compatible avec le modèle de maturité du JRC  (model -> shadow -> twin).

Les jumeaux numériques ne sont pas coûteux parce qu’ils intègrent beaucoup de visualisation ou des capacités de reporting. Ils sont coûteux parce qu’ils constituent une réplique du système cible qui, tout comme l’original, doit continuer à fonctionner correctement au fil du temps. Pour aller au-delà de la hype, ils nécessitent un investissement constant en maintenance. Ces coûts récurrents comprennent au moins les éléments suivants :

• monitoring et validation : un jumeau numérique doit suivre chaque modification apportée au système cible avec la plus grande précision possible, ce qui nécessite des mises à jour régulières ;
• maintenance des règles et traçabilité : cela représente un coût important, surtout lorsque les règles changent fréquemment. C’est là que la gestion des versions, les suites de tests et la gestion des changements jouent un rôle ;
• fonctionnement des pipelines de données et interopérabilité : cela englobe également la sémantique, le contrôle des accès, la qualité des données, la précision et la sécurité.
• confidentialité et conformité : indispensables, certainement pour les systèmes qui traitent des données à caractère personnel (santé, revenus, famille).

Pour un cas d’utilisation administratif, la meilleure première étape consiste donc à mettre en place de manière systématique ce que l’on pourrait appeler une “ombre numérique respectueuse de la vie privée” : initialement limitée à des fonctionnalités de monitoring et de replay, avec un contrôle d’accès strict et une minimisation des données. On peut ensuite envisager une extension à des simulations sur des jeux de données anonymisées ou synthétiques. Une éventuelle synchronisation en temps quasi réel avec les données du système cible réel, afin de créer un véritable jumeau numérique, ne peut intervenir qu’à la fin du processus et s’avère souvent assez complexe à mettre en œuvre.

Conclusion

Un jumeau numérique est-il la solution adéquate, ou existe-t-il une alternative plus simple ?
En résumé, les jumeaux numériques ne doivent être envisagés que si toutes les conditions suivantes sont remplies (sinon, une autre approche peut s’avérer plus efficace et mieux adaptée) :

• Le système cible modélisé est dynamique : les résultats dépendent de situations en constante évolution (flux de dossiers, files d’attente, cycle de vie des événements), et pas uniquement de contrôles d’éligibilité ou de formulaires.
• Il est possible d’identifier des sources de données de référence et de maintenir une synchronisation continue. Sans mises à jour régulières avec des données opérationnelles, on construit un modèle et non un jumeau.
• Les simulations mènent à de vraies décisions. Si l’organisation ne dispose pas d’une liberté suffisante pour intervenir (modification des politiques, adaptation du flux de dossiers, priorisation, tâches du personnel…), une série de tableaux de bord suffira probablement.
• Il existe un plan crédible d’audit et de contrôle qualité permanent. Cela ne doit pas être une considération a posteriori, mais un critère d’acceptation. Il est inutile de construire un jumeau qui se détériore plus vite que le système cible.
• L’environnement juridique et de conformité est compatible. Si des données à caractère personnel sont impliquées, le RGPD et l’AI Act peuvent entraîner des obligations qui influencent fortement la faisabilité et le coût. Cela peut limiter un jumeau à un simple système de test amélioré au lieu d’apporter une véritable contribution à l’automatisation opérationnelle.

Un système non jumeau peut également s’avérer utile : avec des règles codifiées, un harnais de test et un monitoring, on dispose déjà d’une configuration transparente permettant d’obtenir toutes sortes d’informations, sans la complexité ni le coût d’une synchronisation complète ou d’une infrastructure de simulation. Dans un environnement administratif, un tel modèle de politique peut déjà répondre à de nombreux besoins sans jumeau numérique opérationnel, même si cela risque d’être décevant pour ceux qui aiment s’appuyer sur des mots à la mode.

Van het concept Digital Twin claimt de NASA dat zij het als eersten toepasten. Om beter het gedrag te kunnen voorspellen van wat ze de ruimte in schoten, had men nood aan een kopie op aarde – niet alleen fysiek, maar ook digitaal. Sommige scenario’s zijn nu eenmaal moeilijk na te bootsen op aarde, maar moeten wel zo gedetailleerd mogelijk doorgerekend kunnen worden. Deze aanpak vond navolging in andere industrieën, zoals de luchtvaart, waar ontwerpfouten catastrofale gevolgen zouden kunnen hebben, of waar een trial-and-error methodiek te duur of praktisch onmogelijk zou zijn.

Digital Twin verschijnt echter pas als onderwerp op de radar van Gartner eind 2016. Ook de Wikipedia-pagina over het onderwerp is een relatief recent gegeven, aangemaakt in 2015, veel later dan die over Virtual Reality (2001) en Internet of Things (2007). Het idee van Digital Twins werd echter snel populair, daarbij geholpen door het Europese Horizon-2020 programma dat er brood in zag en verschillende projecten rond het thema financierde voor miljoenen euro’s ([1], [2], [3], [4]). Alvast in Vlaanderen heeft men die kans gretig gegrepen, met IMEC in een centrale rol, bijgestaan door een enthousiast Digitaal Vlaanderen, en ook VITO is overtuigd.

Marketinggewijs heeft de Digital Twin zijn waarde dus alvast bewezen. Maar kan het een concrete meerwaarde zijn voor publieke administraties? Ook daar worden workflows snel complex, kunnen wijzigingen duur zijn, en wil men misschien éen en ander kunnen simuleren alvorens het effectief te implementeren. In dit artikel onderzoeken we wat de Digital Twin kan betekenen in een administratieve context.

Definities

Er bestaan nogal wat verschillende interpretaties van Digital Twin. De essentie is alleszins niet nieuw: een systeem wordt digitaal weergegeven zodat het kan worden geobserveerd, getest en verbeterd zonder de daadwerkelijke werking direct aan te tasten. Het belangrijkste onderscheidende kenmerk is de continue (of in ieder geval regelmatige) synchronisatie tussen het reële systeem (de ‘doelentiteit’ of ‘target entity’), en zijn digitale tegenhanger. De EU JRC adopteert een maturiteitsmodel dat verschillende niveau’s van integratie onderscheidt; enkel in het geval van tweerichtings-datauitwisseling tussen target en twin wordt echt van een twin gesproken. Op internationaal vlak worden pogingen ondernomen tot standaardisering van terminologie.

Om nuttig te kunnen zijn moet een Digital Twin uitgewerkt zijn in voldoende detail. Al naargelang de toepassing zal het niveau van granulariteit of resolutie variëren. De twin moet de doelentiteit gedurende diens volledige life cycle getrouw kunnen weergeven, maar dat betekent niet dat elk detail tot in de puntjes gesimuleerd moet zijn. In de medische sector zien we digital twins opduiken op het niveau van de cel, van het orgaan, van een persoon of van de populatie. Niets belet ook dat een Digital Twin slechts een onderdeeltje vormt van een groter systeem – het kan bijvoorbeeld alleen maar uitgewerkt zijn voor 1 kritische component.

We kunnen twee stromingen van Digital Twins onderscheiden:

• Hoogwaardige technologische twins (luchtvaart, industrie, infrastructuur), waarbij de twin wordt gebruikt voor diagnostiek, voorspellend onderhoud of iteratief ontwerp op basis van operationele gegevens – bij NASA, voor elektriciteitsdistributie, …
• Informatiesysteem- of socio-technische twins (steden, organisaties, dienstverlening), waarbij de doelentiteit niet zozeer een machine is maar eerder een complex systeem met meerdere belanghebbenden, bestaande uit processen, regels, mensen en gegevensstromen. Deze tweede stroom is waar de publieke sector in past, maar het is ook waar de definities vaag worden en Digital Twin soms wordt gebruikt als marketingterm voor ‘dashboard+model’.

Waar beleidsmatig enige vaagheid misschien onvermijdelijk is, willen we in de praktijk toch een meer operationele interpretatie. We zouden een administratieve digital twin kunnen definiëren als: een continu geüpdatete, testbare, digitale representatie van de realiteit van de dienstverlening. Dit omvat processen, dossiers en de status waarin die zich bevinden, een uitvoerbaar systeem van de regels die van toepassing zijn, en alle dataverkeer dat nodig is om het geheel te doen werken. Dat moet toelaten de huidige realiteit van nabij te monitoren, en eventuele wijzigingen vooraf te simuleren voordat ze worden toegepast.

Voor een industrieel proces gedreven door sensordata en de onveranderlijke wetten van de fysica, ligt dat gemakkelijker dan voor het overheidswezen, waar men vaak gevoelige gegevens verwerkt en afhangt van regelmatig wijzigende regels die ruimte laten voor interpretatie (zie ook onze eerder gepubliceerde artikels over Rules As Code). Bezorgdheden rond data governance (GDPR etc.) kunnen het moeilijk maken om synchronisatie met real-time gegevens op te zetten. Beslissingslogica is vaak nauw verweven met de code van applicaties, wat aanpassingen en compliance checking bemoeilijkt. Het is daarom vaak al een hele prestatie als men in overheidscontext tot een Digital Shadow komt, die we ergens kunnen situeren tussen een “dom” model en een echte gesynchroniseerde twin.

Toonaangevende projecten

In Europa gaan de opvallendste Digital Twin projecten overwegend over klimaat en wetenschap:

• Destination Earth of DestinE combineert grootschalige gegevens van (weer)satellieten en Copernicus in een data lake. Op basis daarvan zagen 2 Digital Twins het licht: Climate Change Adaptation (langetermijn) en Weather-induced Extremes (kortetermijn). Daarvoor ontwikkelden ze hun eigen Digital Twin Engine. Het project wordt voortgezet, waarbij men gemakkelijker “downstream applicaties” van externe gebruikers wil faciliteren die deelaspecten of specifieke onderzoeksvragen verder kunnen uitdiepen. Dat alles moet gedeeld worden via 1 platform gecoördineerd door ESA.
• Het EDITO project probeert gelijkaardige doelstellingen te bereiken maar dan voor oceanen. Hiervoor wordt data van EMODnet en Copernicus samengebracht. Toegang verloopt via een Datalab dat ook een reeks andere bouwblokken en services aanbiedt, en de applicaties die erop gebouwd worden kunnen een plaats krijgen op het digitaal platform van het initiatief.
• Verschillende use cases worden ook opgelijst in het kader van het recent afgelopen (en Europees gefinancierde) interTwin onderzoeksproject, dat een enigszins gestandaardiseerde architectuur met herbruikbare componenten voor Digital Twins trachtte ontwikkelen. Zij benaderden het onderwerp eerder vanuit de wereld van het CERN, en onafhankelijk van de twee eerder vermelde initiatieven. Onderweg leerden ze wel van elkaars bestaan en werd een mogelijke interoperabiliteit met het ESA-gelinkte DestinE alvast onderzocht.

In een administratieve context hebben we minder boodschap aan gegevens van satellieten of deeltjesversnellers. Omwille van de governance-vereisten komt de nadruk veeleer te liggen op correcte interoperabiliteit en data-uitwisseling, conform alle geldende wettelijke kaders. In dat opzicht zijn de nuttigste Europese initiatieven misschien nog de Data Spaces – voor een “policy twin” bijvoorbeeld de Legal Data Space. Er zijn ook raakvlakken met het idee van Regulatory Sandboxes zoals dat opduikt in o.a. de Interoperable Europe Act of recenter de AI Act: een administratieve digital twin kan de rol van zo’n sandbox vervullen als er goede mechanismen voor scenario-ontwikkeling en -evaluatie zijn.

Administratieve Use Cases

Voordat we zelf aan de slag zouden gaan in complexe sectoren zoals gezondheidszorg en sociale zekerheid, moeten we ons toch afvragen of Digital Twins echt iets kunnen toevoegen aan wat vandaag al bestaat – want hype op zich draagt niets bij.

Inzake policy modeling voor sociale zekerheid, is er bijvoorbeeld al een sterke basis met het EUROMOD microsimulatie model, waarvan de Belgische variant BELMOD heet. Dit zijn statische microsimulaties waarbij gegevens op fijnmazig niveau worden gecombineerd met gecodeerde regels zodat het mogelijk wordt om hervormingen aan de parameters van de sociale zekerheid te simuleren (bijdragen, uitkeringen, etc.). Zulke studies worden typisch uitgevoerd aan universiteiten, men kan een idee krijgen van wat dat inhoudt via EUROMOD Online.

In zekere zin komt dit type model al in de buurt van een digital twin voor sociaal beleid, maar het mist nog twee cruciale lagen:

• actuele/live koppelingen met administratieve gegevens: hiermee kan men dan budgettaire en verdelingseffecten simuleren op de situatie van vandaag, in plaats van op verouderde data van enkele jaren geleden.
• procesinformatie over de dienstverlening (doorlooptijden van dossiers, behandelingscapaciteit etc): dit zou toelaten ook de operationele impact van hervormingen op de uitvoerende diensten in te schatten.

Het zou allerminst eenvoudig zijn om dat toe te voegen: de gegevens in kwestie zijn zeer gevoelig van aard. De echte data gebruiken als real-time databron voor simulaties zou al zeker verregaande anonymisering vereisen (voortvloeiend uit de GDPR), naast een resem andere veiligheidsmaatregelen. Dat is een complexe oefening op zich, waarbij mogelijk ook nuttige informatie verloren gaat.

De status van een persoon binnen de sociale zekerheid wordt daarenboven bepaald door een opeenvolging van gebeurtenissen die lang kunnen doorwerken en met elkaar interageren (werk, ontslag, ziekte, ongeval, pensioen, geboorte van een kind, …). Om echt waardevol te kunnen zijn zou een twin de hele weg moeten kunnen modelleren die een individu aflegt in het systeem. Niet alleen de individuele status, maar ook die van dossiers (worden er deadlines gemist) en administratie (is er behandelingsachterstand) evolueert doorheen de tijd.

Als er vandaag al een goede digital shadow beschikbaar is van een dienst, dan kan met de toevoeging van evolutieve gegevens over werklastverdeling, capaciteit, dossiervoortgang, … een volgende stap gezet worden, zoals de simulatie van dossierdoorstroming. Zulke selectieve simulaties kunnen dienen voor tegenfeitelijke (“wat-als”) analyses die de impact van verandering (organisatorisch, of in de regelgeving) beter in te schatten maakt. Andersom kan men zoiets ook zien als een framework voor regressietesten: berekeningen op representatieve steekproeven kunnen herhaald worden telkens iets wijzigt, om na te gaan waar de grootste impact ligt.

De administratie van de gezondheidszorg kent andere prioriteiten: opvolging van patiënten en consultaties is tijdskritisch, de toekenning van mensen en middelen is een complexe planningspuzzel, allerlei terugbetalingen en verzekeringen, … Om daarin richting Digital Twin te evolueren kan er een grote rol weggelegd zijn voor de European Health Data Spaces, en voor nieuwe oplossingen die men momenteel tracht uit te denken voor secundair gebruik van gezondheidsdata.

We staan nog ver van de droom van individueel geoptimaliseerde gezondheidszorg op basis van een persoonlijke digital twin van een patiënt – idee dat trouwens ook gepaard gaat met heel wat niet triviale risico’s inzake ethiek en privacy. Op kortere termijn liggen de mogelijkheden eerder op niveau van de organisatie. Met gegevens over opnames, wachtlijsten, personeelsinzet en activiteit, toegevoegd aan een bestaande digital shadow, kunnen strategische en operationele wijzigingen mogelijk beter opgevangen worden.

Implementatie: een kostelijke affaire?

Om de focus te behouden op wat vandaag of op korte termijn mogelijk is, kunnen administraties zich inspireren op “reference stacks” van technologische componenten, die uitgebouwd zijn in het kader van bestaande digital twins. Enkele daarvan haalden we reeds eerder aan en herhalen we hier niet.

Een Digital Twin moet een representatie kunnen bevatten van de huidige staat van een systeem, en moet gebeurtenissen kunnen verwerken die daarop een impact hebben. In het kader van de Europese FIWARE initiatieven (Future Internet) werd daarvoor door een werkgroep Context Information Management bij ETSI de NSGI-LD standaard en API ontwikkeld. Het lijkt er echter op dat er nog niet veel adoptie is van deze standaard buiten het eigen netwerk van voornamelijk Smart City en IoT-initiatieven.

Administratieve systemen bestaan niet louter uit beslissingen. De processen omvatten interactie, documenten, en soms ook enige beoordelingsvrijheid. Open standaarden uit de business process management wereld komen hier van pas. DMN (decision modeling), BPMN (business processes) en CMMN (case management) zijn complementair aan elkaar en laten het modelleren van deze aspecten toe. Op deze initiatieven verschijnen ook uitbreidingen, zoals het aan de KULeuven ontwikkelde Constraint DMN (cDMN) dat complexere logica toelaat. Een Digital Twin kunnen we dan samenstellen uit een DMN beslissingsmotor die berekent “wat de regels zeggen” (hier kan Rules As Code eventueel een plaats krijgen), verrijkt met lagen die de processen en caseflow voor hun rekening nemen (status, deadlines, ondersteunende documenten), en tot slot een regelmatige synchronisatie om de operationele status (of context) te kunnen updaten. Dit is compatibel met het JRC maturiteitsmodel (model -> schaduw -> twin).

Digital Twins zijn niet duur omdat ze veel visualisatie bevatten of rapporteringsmogelijkheden ingebouwd hebben. Ze zijn duur omdat ze een duplicaat vormen van het doelsysteem, dat net zoals het origineel, doorheen de tijd correct moet blijven werken. Om meer te zijn dan enkel hype, is constante investering in onderhoud nodig. Die recurrente kosten omvatten ten minste het volgende:

• monitoring en validatie: een digital twin moet elke verandering aan het doelsysteem zo accuraat mogelijk volgen, dit vraagt regelmatige updates,
• onderhoud van de regels en traceerbaarheid: zeker wanneer regels vaak wijzigen is dit een grote kost. Hier spelen versionering, test suites en veranderingsmanagement een rol,
• functioneren van data pipelines en interoperabiliteit: omvat ook semantiek, toegangscontrole, datakwaliteit, accuraatheid en beveiliging,
• privacy en compliance: onontbeerlijk, zeker voor systemen die persoonsgegevens verwerken (gezondheid, inkomen, familie)

Voor een administratieve use case is de beste eerste stap daarom een stelselmatige uitbouw van wat we een privacy-aware digital shadow zouden kunnen noemen: initieel beperkt tot monitoring + replay functionaliteit, met strikte toegangscontrole en dataminimalisatie. Daarna kan gedacht worden aan uitbreiding met simulaties op geanonimiseerde of synthetische datasets. Eventuele near-real-time synchronisatie met gegevens uit het echte doelsysteem, om een echte Digital Twin te vormen, kan pas op het einde volgen, en heeft vaak nogal wat voeten in de aarde.

Conclusie

Is een Digital Twin het juiste type oplossing, of kan het ook eenvoudiger? Samengevat zijn Digital Twins pas te overwegen als al het volgende waar is (anders kan een andere aanpak efficiënter zijn en beter aansluiten):

• Het doelsysteem dat gemodelleerd wordt is dynamisch: uitkomsten hangen af van evoluerende situaties (caseflow, wachtrijen, levenscyclus van gebeurtenissen), niet enkel van eligibility checks of formulieren.
• Je kan referentiedatabronnen identificeren en doorlopende synchronisatie volhouden. Zonder regelmatige updates met operationele data, bouw je een model en geen twin.
• Simulaties leiden tot echte beslissingen. Als de organisatie niet voldoende vrijheid heeft om in te grijpen (beleid veranderen, caseflow wijzigen, prioritisering, personeelstaken, …), zal een reeks dashboards waarschijnlijk volstaan.
• Er is een geloofwaardig plan voor audit en permanente kwaliteitsbewaking. Dit mag niet achteraf komen maar moet een acceptatiecriterium zijn. Het heeft geen zin een twin te bouwen die sneller rot dan het doelsysteem.
• De wettelijke/compliance omgeving is compatibel. Als er persoonsgegevens aan te pas komen kunnen GDPR en AI Act verplichtingen met zich meebrengen die de haalbaarheid en de kostprijs erg beïnvloeden. Dat kan een Twin limiteren tot een veredeld testsysteem in plaats van een echte bijdrage tot operationele automatisering te leveren.

Een niet-Twin kan ook waardevol zijn – met gecodeerde regels + testharnas + monitoring heb je ook al een transparante setup waarmee allerlei inzichten verworven kunnen worden, zonder de complexiteit en kost van volledige synchronisatie of simulatie-infrastructuur. In een administratieve omgeving kan zulk policy model al veel noden lenigen zonder operationele digital twin, al zal dat misschien teleurstellend zijn voor wie graag uitpakt met trendy buzzwords.

Dans un article précédent, nous avons examiné Rules as Code, une approche visant à réduire l’écart entre les réglementations et les logiciels. Nous avons illustré qu’il existe de nombreux obstacles pratiques à surmonter, malgré l’objectif louable. L’encodage uniforme des règles avec leur historique, leurs interdépendances et leurs dépendances est un défi qui peut nécessiter un investissement considérable en termes de personnel et de ressources. De plus, une gestion active permanente est nécessaire pour prendre en compte chaque modification apportée aux règles. Même à petite échelle, une collaboration étroite entre juristes et développeurs est indispensable, car des décisions motivées devront régulièrement être prises en matière d’interprétation. En l’absence de normes industrielles et alors que les meilleures pratiques sont encore en cours d’élaboration, les early adopters risquent de devoir payer la pioneer tax. La complexité des compétences gouvernementales ne facilite pas une éventuelle application en Belgique.

Partiellement sous l’impulsion du rapport détaillé de l’OCDE de 2020, certaines administrations se sont déjà pleinement engagées dans l’élaboration de proof-of-concepts, parfois à grande échelle. Il existe donc aujourd’hui plusieurs cadres relativement matures. La France est sans aucun doute le pays pionnier ; l’initiative que nous allons présenter ci-dessous vient de France. Les Pays-Bas ne sont pas en reste : l’administration fiscale néerlandaise utilise depuis un certain temps déjà son propre langage de domaine, RegelSpraak, qu’elle interprète et traite à l’aide du rule engine ALEF. Cependant, le code source publié à ce sujet semble pour l’instant se concentrer davantage sur la méthodologie que sur les applications.

OpenFisca

OpenFisca a vu le jour en 2011 en tant que moteur de microsimulation open source permettant de convertir les règles fiscales et sociales (“tax & benefit system”) en code exécutable. Les effets de cette réglementation, et les éventuelles modifications, peuvent alors être simulés tant pour des cas individuels que pour des populations entières. Parmi les sites web utilisant OpenFisca en arrière-plan, on peut citer LexImpact (simulation des modifications de la législation socio-fiscale), Mes droits sociaux (simulation des droits sociaux) et 1jeune1solution (mesures de soutien diverses). Parmi les exemples étrangers, citons BenefitMe (Nouvelle-Zélande), Les meves ajudes (Barcelone) ou PolicyEngine (Royaume-Uni/États-Unis) – ces derniers ayant toutefois nécessité des modifications importantes du moteur.

Afin de modéliser notre propre système fiscal et/ou de sécurité sociale, nous devons créer une fourche du Template country OpenFisca générique. Plusieurs autres pays ont déjà expérimenté cette approche, comme le Sénégal, le Paraguay et la Tunisie, qui figurent dans la liste des repositories. La législation régionale ou locale peut être ajoutée grâce à des extensions pluginà un système national, comme celui de Paris. Une fois le repository initialisé, nous pouvons commencer à travailler sur ce qui pourrait un jour devenir openfisca-belgium. La modélisation dans OpenFisca se fait en écrivant des classes et des méthodes Python, qui représentent les entités, les variables et les formules de calcul issues de la réglementation.

Malheureusement, c’est à peu près là que s’arrête la partie facile. Le repository du country template est minimaliste et, bien qu’il existe une documentation avec un petit tutoriel pour créer sa propre version, celle-ci se concentre principalement sur les premières étapes. Les directives sur la manière de structurer au mieux notre propre fourche dès que le nombre de variables et de paramètres augmente font largement défaut. Le repository du projet parent openfisca-france peut certes servir d’exemple, mais il est très volumineux et ne permet pas vraiment de comprendre les raisons de leurs choix structurels ou architecturaux.

L’aspect d’une GUI ou d’une interface web reste également sous-estimé. Pourtant, l’interface de LexImpact simulator pour l’impôt sur le revenu en France, par exemple, est justement un point fort. Comme guide pour la construction d’une interface web, on se réfère à tutoriels et slides d’un workshop, où les premières étapes sont présentées dans Svelte, React et VueJS. Cependant, le fait qu’une GUI ou une application web doive encore être construite from scratch en plus d’une instance OpenFisca propre constitue un obstacle supplémentaire à l’adoption. La construction d’une GUI est en effet chronophage. Il serait utile de disposer de bibliothèques OpenFisca-GUI avec des composants réutilisables pour les principaux frameworks web, afin qu’un serveur OpenFisca puisse éventuellement être associé à une interface web générique par défaut. Un plugin Drupal semble actuellement être le seul à aller quelque peu dans cette direction.

L’IA à la rescousse ?

Étant donné qu’OpenFisca, Svelte, React et Vue sont tous nouveaux pour l’auteur, et que les outils d’IA promettent d’accélérer l’intégration des développeurs, nous saisissons l’occasion pour tester simultanément l’IDE Cursor alimenté par l’IA. Ce clone de Visual Studio Code est enrichi de la possibilité d’appeler des LLM (dans notre cas, basés sur le cloud public). De plus, des sélections issues de fichiers du projet peuvent être marquées comme contexte pour la question. Cursor peut fournir des suggestions d’ajouts ou de modifications à apporter aux fichiers qui, une fois approuvées, peuvent être directement intégrées dans la base de code.

Interagir avec des modèles d’IA comporte des risques pour la confidentialité. Cette expérience est principalement possible car nous travaillons avec du code open source, des réglementations publiées et leur documentation également publique, qui ne sont pas sensibles. Cependant, étant donné que tout ce qui se trouve dans l’IDE peut être envoyé au modèle de langage, nous devons toujours veiller à ne pas ouvrir dans l’IDE des fichiers contenant des identifiants, des clés API ou des informations personnelles. Cela reste la responsabilité de chaque développeur. Dans tous les cas, il est recommandé d’être prêt à faire tourner les clés API ou les credentials, car dans le feu de l’action d’un debugging, il est facile de partager trop d’informations avec un LLM.

Enfin, il convient de mentionner que cette expérience a été réalisée avec les versions 1.6 et 1.7 de Cursor en septembre-octobre 2025, avec le modèle de langage sous-jacent GPT-4.5 d’OpenAI, puis GPT-5.0, utilisé avec une clé API dédiée (et non via Cursor). Les versions ultérieures disposent de nombreuses fonctionnalités plus récentes (notamment des workflows agentic) et il est possible que l’expérience soit aujourd’hui (janvier 2026) très différente. Cependant, les principaux enseignements restent généralement valables pour tout développement alimenté par l’IA, que ce soit via IDE, ligne de commande ou les deux (par exemple, Anthropic Claude Code).

Dans un premier temps, nous ajoutons la documentation nécessaire à notre projet. Nous prenons comme exemple la loi du 26 mai 2002 concernant le droit à l’intégration sociale. Avec tous les autres arrêtés royaux, lois et circulaires pertinents, elle est clairement répertoriée sur le site web du SPP Intégration sociale. Afin de faciliter la recherche et l’interprétation du texte pour un LLM dans un IDE, nous l’enregistrons sous forme de fichier texte plat sans mise en forme, que nous ajoutons à un nouveau dossier contenant les sources pertinentes dans l’arborescence source du projet. Nous ne pouvons que supposer que cette approche est optimale, mais il faut bien commencer quelque part.

Entités

Les entités dans OpenFisca indiquent pour qui nous effectuons le calcul. Il peut s’agir d’individus, de familles ou d’autres groupes de personnes (entreprises, organisations, etc.). Ce sont les fondements sur lesquels nous pourrons ensuite spécifier des variables qui, ensemble, formeront une “situation” pour laquelle nous pourrons effectuer un calcul. Les entités Person et Household sont déjà présentes dans le code. Une question logique se pose donc : sur la base du texte de loi donné, pouvons-nous définir d’autres entités qui seraient utiles ?

Après avoir posé la question à GPT-5 dans Cursor, avec le texte de loi sélectionné comme contexte, il nous est proposé d’ajouter les entités suivantes :

• Eligible Person for Societal Integration
• Living Wage Recipient
• Employment Project Participant

Les modifications proposées au code sont syntaxiquement correctes. Cependant, aucune de ces trois modifications n’est utile ou nécessaire : dans les trois cas, il s’agit de variantes de Person. Les propriétés qui leur permettraient, par exemple, de percevoir un revenu d’intégration sont plutôt des variables ajoutées à l’entité Person déjà existante. La valeur de ces variables dépend en outre d’autres variables également liées à ce même individu, telles que les revenus du travail ou le statut d’invalidité. Les entités, qui servent principalement à des concepts autonomes, ne sont pas le bon choix dans ce cas. 

En outre, GPT-5 semble avoir mal interprété le concept de “rôle” au sein d’une entité de groupe OpenFisca. Il tente de construire “Eligible Person for Societal Integration” avec différents “rôles” comme composants : “Belgian National”, “EU Citizen”, “Foreigner”, “Stateless”, “Refugee”… Sans doute parce que ces possibilités apparaissent à l’Art.3, 3°, de la loi. Dans OpenFisca, cependant, une entité de groupe est composée de personnes qui se voient chacune attribuer un rôle. Un Household comprend ainsi des rôles Adult et Child. Il est assez absurde qu’une EligiblePerson puisse comprendre plusieurs Foreigners. La nationalité ou l’origine, ou d’autres conditions fixées dans cette loi, sont également ici des variables liées à la personne, et non à une entité en soi. 

À un autre moment, une entité distincte a été créée pour le CPAS. Bien qu’il semble logique de modéliser les CPAS et de les considérer comme une entité – ils sont en effet mentionnés dans la loi –, ce n’est pas (encore) le cas ici. Il n’existe en effet pas différents types de CPAS avec des caractéristiques ou des rôles différents, pour lesquels nous devrions effectuer des calculs différents à chaque fois. Dans le contexte de cette loi, où c’est le citoyen pour lequel nous calculons le droit à l’aide sociale, le CPAS est avant tout une donnée constante et invariable. Dans OpenFisca, nous pouvons donc pour l’instant ignorer cet aspect. (Un type d’entité “institut” n’est pas non plus prévu.) 

Nous constatons ici que Cursor ne peut pas répondre “non” à la question de savoir si d’autres entités utiles peuvent être ajoutées. Il ne peut pas critiquer ou corriger de son propre chef le raisonnement qui sous-tend cette question. Tout au long de l’expérience, Cursor et GPT-5 ont également montré une tendance à la complexité inutile. Cela représente un risque important pour les développeurs qui travaillent avec du code ou des frameworks inconnus : si l’on suit trop rapidement ces suggestions, on risque de perdre le contrôle par la suite et de devoir apporter des corrections très difficiles aux fondements du projet. Une fois qu’une mauvaise voie a été empruntée, il s’avère également difficile de revenir en arrière et de faire oublier ces étapes. Surtout si on les a d’abord acceptées par ignorance, elles s’inscrivent dans le contexte et sont reprises dans les questions suivantes. Ce “context rot” insidieux est désormais un problème bien connu et une cause importante de perte de temps avec le AI enabled coding.

Variables

Le cœur du modèle réside dans les variables qui représentent les droits et les conditions prévus par la loi. L’article 2 de la loi énumère les différentes formes d’intégration sociale auxquelles une personne peut avoir droit (notamment l’emploi, le revenu d’intégration, le projet individualisé). L’article 3 contient les conditions qu’une personne doit remplir pour exercer ce droit. Nous avons transposé ces dispositions étape par étape dans le code.

Dans la pratique, le droit à l’intégration sociale signifie qu’un CPAS doit soutenir une personne par le biais (1) d’un emploi ou d’une formation, (2) d’un revenu d’intégration, ou (3) d’un projet individualisé d’intégration sociale. Cela peut se traduire par trois variables booléennes sur l’entité Personne, par exemple employment_right, living_wage_right et individualized_project_right. Cursor fournit ici une suggestion de code pertinente et propose une formule placeholder simple : tant qu’une personne “est éligible à l’intégration” (une autre variable), le droit s’applique. Nous obtenons ainsi la définition suivante de employment_right :

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

Le contenu de cette formule placeholder est abordé dans l’article 3 ci-dessous. Celui-ci modélise les conditions suivantes pour être éligible :

• Séjour en Belgique (selon les règles à déterminer par arrêté royal).
• Âge : la personne est majeure (18 ans et plus) ou, si elle est mineure, assimilée à une personne majeure selon les exceptions prévues par la présente loi.
• Nationalité ou statut de séjour : la personne est belge, citoyenne de l’UE (après 3 mois de séjour), étrangère enregistrée, apatride, réfugiée ou bénéficiaire d’une protection subsidiaire.
• Ressources insuffisantes
• Disposition à travailler (sauf si cela est impossible pour des raisons de santé ou d’équité).
• Épuisement des droits issus d’autres régimes

Toutes ces conditions sont regroupées dans une variable booléenne centrale societal_integration_right. Cette variable indique si une personne, compte tenu de sa situation personnelle, peut prétendre à l’intégration sociale. En fait, il s’agit de la traduction de “la personne remplit-elle toutes les conditions de l’article 3 ?“. La formule combine toutes les sous-conditions :

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

Notons ici quelques lacunes étranges dans la suggestion de Cursor. Ainsi, le nom de la variable societal_integration_right n’est pas identique au placeholder eligible_for_integration défini précédemment, alors que c’était pourtant l’intention. En outre, la condition de nationalité omet tout simplement la possibilité d’une protection subsidiaire. Enfin, la sixième condition, qui stipule que la personne doit d’abord faire valoir ses droits à d’éventuelles prestations sociales, est mentionnée de manière très rudimentaire sous le nom de claiming_benefits, un nom de variable qui ne reflète pas vraiment ce qui est visé.

Nous pouvons donc accepter cette suggestion, mais nous sommes immédiatement obligés d’apporter trois corrections. Nous pouvons facilement détecter la non-conformité du nom de la variable, car les tests ne fonctionneront pas s’il reste des variables non déclarées dans le code. Un élément manquant dans la formule, tel qu’une condition oubliée, est cependant beaucoup plus facile à négliger et, s’il n’est pas détecté, entraîne à coup sûr des erreurs d’exécution. Nous constatons donc ici la nécessité de se référer au texte de loi afin de vérifier que le code généré correspond bien à ce que dit le texte de loi. Cette vérification doit être effectuée avec suffisamment d’attention pour pouvoir identifier les appellations malheureuses ou les interprétations subtiles erronées du texte.

Les corrections éventuelles doivent également être effectuées le plus rapidement possible. Si un code erroné reste présent dans l’éditeur, il fera en effet partie du contexte utilisé par le modèle d’IA et servira lui-même de base pour les suggestions suivantes. Cela peut conduire à une situation où l’on continue à recevoir des suggestions contenant toujours les mêmes erreurs, qu’il faut donc corriger à chaque fois, ce qui n’est pas propice à la productivité.

Les variables utilisées dans la méthode formula() de societal_integration_right ci-dessus doivent bien sûr être définies à leur tour : pour chacune de ces variables, nous devons écrire une classe. Cela peut donner lieu à des chaînes complexes de dépendances. Ainsi, is_major pourrait être une simple variable d’entrée booléenne, mais nous pouvons également la calculer sur la base de la date du jour et d’une nouvelle variable birthdate. Le calcul de la formule des variables peut également utiliser les paramètres d’une loi – ainsi, en Belgique, la majorité n’est atteinte qu’à partir de 18 ans depuis le 1^er mai 1990. Cela nous ramènerait alors au Code civil et à son histoire – pour rester concis, nous n’approfondirons pas cette question pour l’instant.

Dernière remarque : le modèle tel qu’il est construit ici est bien sûr une représentation simplifiée. Notez toutefois que même dans ce cas, après seulement trois articles de loi, nous avons déjà défini une dizaine de classes Python, avec la possibilité d’en ajouter d’autres si nous souhaitons approfondir le sujet. Cursor et GPT-5 écrivent un code relativement verbeux, avec de nombreuses variables et méthodes auxiliaires, qui pourraient parfois être simplifiées. Certains détails de la loi, tels que le délai d’attente de trois mois pour les citoyens de l’UE ou les exceptions qui existent pour certaines catégories de mineurs (art. 7), nécessiteraient de nombreuses variables ou conditions supplémentaires dans un modèle complet.

IA et code : quelques pièges

En ce qui concerne les meilleures pratiques pour l’utilisation de l’IA dans le cadre de tels projets, nous identifions encore quelques pièges, en plus de ceux que nous avons déjà mentionnés.

Ajouter trop de documentation au début conduit rapidement à une “confusion contextuelle“, dans laquelle les suggestions ou les réponses du LLM sont basées sur des informations qui ne sont pas (encore) pertinentes. Il est préférable d’ajouter la documentation progressivement, au fur et à mesure que la fonctionnalité se développe, plutôt que d’ajouter l’analyse complète et le contexte à l’IDE dès le départ. Dans le cas de la réglementation, ajoutez les règles article par article à l’IDE, au fur et à mesure de l’avancement du projet, et résistez à la tentation d’intégrer à l’avance l’ensemble du texte de loi dans l’IDE en tant que “référence encyclopédique”.

Le “context rot” ou “context poisoning” survient lorsque l’IA s’engage dans une mauvaise voie, s’y enlise et finit par oublier des informations plus pertinentes, ce qui rend la récupération plus difficile. Le “context quarantining“, qui consiste à diviser le problème en sous-problèmes plus petits, chacun avec son propre contexte, est un remède logique à ce problème. C’est également la voie empruntée par la plupart des systèmes de “deep research” ou “multi agentic“. Dans un IDE, cela impliquerait qu’un système d’IA devrait segmenter la base de code et la documentation à partir d’une certaine taille. La mise en œuvre technique de cette solution en arrière-plan semble être un défi de taille, et différents IDE développeront probablement leur propre approche à cet égard dans un avenir proche.

Une autre source de frustration était que l’IA plaçait parfois le code ou les fichiers au mauvais endroit ou supposait que certaines choses existaient. Par exemple, les formules générées faisaient référence à des variables qui n’étaient pas encore définies. Cela génère bien sûr des messages d’erreur lors des tests. Nous devions alors ajuster l’IA ou insérer nous-mêmes des variables supplémentaires pour couvrir ces références. Même des détails mineurs, tels que le formatage de la documentation ou la création ou non des importations nécessaires, nécessitaient parfois une correction manuelle. Ce type d’incohérences démontre qu’il n’est pas possible de se fier aveuglément aux suggestions de l’IA. Un développeur doit constamment vérifier si le code généré correspond à l’intention et, dans le cas contraire, intervenir immédiatement.

publi.codes

Nous souhaitons également signaler l’existence de publi.codes comme alternative possible à OpenFisca. Plus récent et plus moderne, ce dernier exige que les règles soient codées au format YAML, ce qui est beaucoup plus pratique que l’écriture de sous-classes en Python et beaucoup plus lisible pour les non-développeurs. En contrepartie, on est toutefois limité aux opérations autorisées par le moteur sous-jacent. Ce n’est qu’à partir de la version 2, encore en cours de développement, que des possibilités d’encoder des barèmes ou des abattements (montants exonérés), très fréquents en Belgique, seront ajoutées.

La version actuelle de publi.codes dépend en outre de l’écosystème NPM, qui est actuellement régulièrement affecté par des attaques du supply chain. Publi.codes v2 serait quant à lui compilé vers OCaml, un langage de programmation que nous n’utilisons pas chez Smals. Étant donné qu’il y a peu de chances que Smals souhaite introduire ce langage de programmation dans son portefeuille (et mettre en place une équipe de support à cet effet), il ne semblait pas très utile d’examiner publi.codes en profondeur dans le cadre de cet exercice. Il convient toutefois de noter que publi.codes dispose de quelques libraries prêtes à l’emploi en matière de composants UI.

Conclusion

OpenFisca et publi.codes sont deux systèmes particulièrement performants lorsque les règles peuvent être modélisées sous forme de calculs explicites et testables. Ils sont moins adaptés aux réglementations qui font appel aux décisions discrétionnaires, à la libre interprétation, aux exceptions sans paramètres clairs ou aux workflows de “case management”. Il s’agit avant tout de systèmes de calcul et de règles, et non de plateformes de traitement de dossiers. Ils peuvent donc éventuellement servir de moteur pour des applications capables de calculer les impôts ou les allocations au niveau de la personne/du ménage (droit à quelque chose + montant), ou pour simuler l’impact politique d’éventuelles modifications (“combien coûte cette réforme ?”, “qui y gagne/y perd ?”). Cela peut être intéressant tant pour les législateurs que pour les citoyens.

Cependant, un projet OpenFisca ne se met pas en place rapidement. Sur le plan conceptuel, OpenFisca est quelque peu déroutant pour un développeur : bien qu’OpenFisca utilise des classes Python, celles-ci ne servent pas à modéliser des objets, mais à enregistrer de manière déclarative des entités, des variables et des règles de calcul issues de la réglementation. Étant donné que par variable, il faut écrire une classe et que des dizaines de variables peuvent facilement entrer en jeu dans un article de loi complexe, on se retrouve avec une pile de code qui s’accumule rapidement et qui est difficile à organiser de manière claire. En outre, le développement d’une interface graphique nécessite également beaucoup de travail supplémentaire. Le projet manque encore de tooling nécessaire pour atténuer ces problèmes récurrents. (Bien sûr, cela n’aide pas lorsque l’administration publique, qui semble considérer que les projets open source peuvent par définition s’autofinancer, décide soudainement de fermer les vannes en 2020.

Enfin, nous pouvons ajouter que cette expérience a été à la fois un reality check utile et instructif sur ce que les LLM peuvent apporter, et gâcher, à un environnement de travail de développeur. Le meilleur conseil reste de garder les rênes fermement en main et de travailler par petites étapes incrémentielles. Certains outils d’IA seront plus performants que d’autres dans divers domaines. Donner des réponses négatives ou détecter des erreurs dans les questions reste un défi pour les LLM, ce qui comporte certains risques. Cependant, l’assistance IA dans les IDE évolue rapidement, et une expérience similaire se déroulera sans doute différemment l’année prochaine.

Rules As Code ne signifie certainement pas qu’aujourd’hui, nous pouvons fournir un texte de loi à une IA pour qu’elle déploie un programme. Cependant, dans les années à venir, les forums spécialisés accorderont sans aucun doute une grande attention à l’interaction entre la loi, la mise en œuvre et les outils d’IA. Pour l’instant, la complexité de la réglementation elle-même, même avec une IA de plus en plus performante, reste le principal obstacle aux projets Rules As Code.

In een vorig artikel fileerden we Rules as Code, een aanpak die erop gericht is om de kloof tussen regelgeving en software te verkleinen. We illustreerden daarbij dat er heel wat praktische obstakels te overkomen zijn, niettegenstaande het lovenswaardige doel. De uniforme encodering van regels met hun geschiedenis, verwevenheden en afhankelijkheden is een uitdaging die een aanzienlijke investering van mensen en middelen kan vergen. Permanent actief beheer is daarenboven nodig om elke wijziging aan de regels op te vangen. Zelfs op kleine schaal is een nauwe samenwerking tussen juristen en ontwikkelaars onontbeerlijk, want regelmatig zullen gemotiveerde beslissingen genomen moeten worden over interpretatie. Omdat industriestandaarden nog ontbreken en best practices nog volop in ontwikkeling zijn, riskeer je als early adopter de zogenaamde pioneer tax te moeten betalen. De complexe lasagna van overheidsbevoegdheden maakt een eventuele toepassing in België niet eenvoudiger.

Mede onder impuls van het uitgebreide rapport van de OESO uit 2020, hebben enkele overheden toch al volop ingezet op het uitwerken van, soms vrij grootschalige, proof-of-concepts. Er bestaan vandaag dan ook enkele frameworks die relatief matuur zijn. Ongetwijfeld is Frankrijk het voortrekkersland; het initiatief dat we hieronder zullen toelichten komt van Franse bodem. Ook in Nederland beweegt er wel wat: de Nederlandse fiscus gebruikt al enige tijd haar eigen domeintaal RegelSpraak die zij met de rule engine ALEF interpreteert en verwerkt, echter lijkt de daarover gepubliceerde broncode vooralsnog meer op methodologie dan op applicaties te focussen.

OpenFisca

OpenFisca is ontstaan in 2011 als open-source microsimulatie-motor om belasting- en uitkeringsregels (“tax & benefit system”) om te zetten naar uitvoerbare code. De effecten van die regelgeving, en eventuele wijzigingen, kunnen dan gesimuleerd worden voor zowel individuele cases als hele populaties. Websites met OpenFisca in de achtergrond zijn onder andere LexImpact (simulatie van wijzigingen in socio-fiscale wetgeving), Mes droits sociaux (simulatie van sociale rechten), en 1jeune1solution (allerhande steunmaatregelen). Buitenlandse voorbeelden zijn BenefitMe (Nieuw-Zeeland), Les meves ajudes (Barcelona), of PolicyEngine (UK/USA) – deze laatsten wel met grondige aanpassingen aan de engine.

Om ons eigen belasting- en/of sociale-zekerheidsstelsel te modelleren, moeten we een fork maken van het generieke OpenFisca country-template. Verschillende andere landen hebben er tenminste al mee geëxperimenteerd, zo vinden we in de lijst van repositories o.a. Senegal, Paraguay en Tunesië. Regionale of lokale wetgeving kan middels plugin-extensies toegevoegd worden aan een nationaal systeem, zoals deze voor Parijs. Eens de repository geïnitialiseerd, kunnen we beginnen werken aan wat misschien ooit openfisca-belgium kan worden. De modellering in OpenFisca gebeurt door het schrijven van Python-klassen en -methodes, die de entiteiten, variabelen en berekeningsformules uit de regelgeving vertegenwoordigen.

Helaas houdt het gemakkelijke deel daar ongeveer op. De country-template repository is minimalistisch en hoewel er wel documentatie, met een kleine tutorial, beschikbaar is om een eigen versie uit te bouwen, focust deze vooral op de eerste stappen. Richtlijnen over hoe we onze eigen fork best zouden structureren zodra het aantal variabelen en parameters groeit, ontbreken grotendeels. De repository van moederproject openfisca-france kan weliswaar als voorbeeld dienen, maar is dan weer erg groot, en het waarom van hun structurele of architecturale keuzes is er niet echt uit af te leiden.

Ook het aspect van een GUI of webinterface blijft onderbelicht. Nochtans is de interface van bijvoorbeeld de LexImpact simulator van de Franse inkomstenbelasting, net een sterk punt. Als leidraad voor bouwen van een webinterface verwijst men naar tutorials en slides van een workshop, waar men de eerste stappen toont in Svelte, React en VueJS. Het is echter een extra barrière voor adoptie, dat een GUI of webapp nog from scratch zelf te bouwen is bovenop een eigen OpenFisca-instantie. Het bouwen van een GUI is immers tijdrovend. Het zou nuttig zijn om OpenFisca-GUI-libraries te hebben met herbruikbare componenten voor de belangrijkste web frameworks, zodat een OpenFisca server misschien met een generieke default webinterface gebundeld kan worden. Een Drupal-plugin lijkt momenteel het enige project dat enigszins in die richting gaat.

AI to the rescue?

Gezien OpenFisca, Svelte, React en Vue allen nieuw zijn voor de auteur, en AI-tooling belooft om developers sneller te laten onboarden, grijpen we de kans om de AI-powered IDE Cursor tegelijk uit te testen. Deze kloon van Visual Studio Code is verrijkt met de mogelijkheid tot het aanroepen van (in ons geval public-cloud-gebaseerde) LLMs. Daarbij kunnen selecties uit bestanden in het project worden gemarkeerd als context bij de vraag. Cursor kan suggesties geven voor toevoegingen of wijzigingen aan bestanden die, eens goedgekeurd, direct geïntegreerd kunnen worden in de codebase.

Interageren met AI-modellen houdt privacy-risico’s in. Dit experiment vooral mogelijk omdat we werken met open-source code, gepubliceerde regelgeving, en de eveneens openbare documentatie daarvan, wat niet gevoelig is. Maar gezien alles wat zich in de IDE bevindt naar het taalmodel gestuurd kan worden, moeten we er nog steeds op letten dat we geen bestanden openen in de IDE die credentials, API keys of persoonlijke informatie bevatten. Dat blijft de verantwoordelijkheid van de individuele developer. Sowieso is het goede praktijk om voorbereid te zijn op het roteren van API keys of credentials, want in het heetst van een debugging-strijd is oversharing met een LLM snel gebeurd.

Tot slot moeten we vermelden dat dit experiment nog werd uitgevoerd met Cursor versies 1.6 en 1.7 in september-oktober 2025, met OpenAI’s GPT-4.5 en later GPT-5.0 als achterliggend taalmodel, gebruikt met een eigen API key (niet via Cursor). Latere versies hebben heel wat nieuwere features (waaronder meer agentic workflows) en het zou kunnen dat de ervaring vandaag (januari 2026) al heel anders zou zijn. De belangrijkste lessen blijven echter algemeen gelden voor alle AI-powered development, of dat nu via IDE, command line of beide gebeurt (vb. Anthropic Claude Code).

Als eerste stap voegen we de nodige documentatie toe aan ons project. Als case nemen we de Wet op de Maatschappelijke Integratie van 26 mei 2002. Samen met alle andere relevante wetten, koninklijke besluiten en omzendbrieven is die overzichtelijk geïnventariseerd op de website van de POD Maatschappelijke Integratie. Om de tekst gemakkelijk doorzoekbaar en interpreteerbaar te maken voor een LLM in een IDE, slaan we hem op als plat tekstbestand zonder opmaak, en dat voegen we toe aan een nieuw mapje voor relevant bronmateriaal in de source tree van het project. Of dat optimaal is, daar hebben we het raden naar, maar we moeten ergens beginnen.

Entiteiten

Entiteiten in OpenFisca drukken uit voor wie we de berekening maken. Dat kunnen individuen, gezinnen of andere groeperingen van mensen zijn (bedrijven, organisaties, …). Het zijn de basisbouwstenen waarvoor we later variabelen zullen kunnen specifiëren die samen een “situatie” vormen waarvoor we een berekening zullen kunnen doen. Person en Household zijn al aanwezig in de code. Een logische vraag is dus of we, op basis van de gegeven wettekst, andere entiteiten kunnen definiëren die nuttig zouden zijn.

Na het stellen van de vraag aan GPT-5 in Cursor, met de wettekst geselecteerd als context, wordt voorgesteld de volgende entiteiten toe te voegen:

• Eligible Person for Societal Integration
• Living Wage Recipient
• Employment Project Participant

De voorgestelde aanpassingen aan de code zijn syntactisch correct. Geen van deze 3 zijn echter nuttig of noodzakelijk: het gaat in alledrie de gevallen om varianten van Person. De eigenschappen die maken dat ze bijvoorbeeld een leefloon zouden ontvangen, zijn veeleer variabelen toegevoegd aan de reeds bestaande Person entiteit. De waarde van die variabelen hangt bovendien af van andere variabelen die eveneens aan datzelfde individu gebonden zijn, zoals een inkomen uit werk of een handicapstatus. Entiteiten, die vooral dienen voor op zichzelf staande concepten, zijn hiervoor niet de juiste keuze.

Daarnaast lijkt GPT-5 het concept van een “rol” binnen een OpenFisca groepsentiteit verkeerd te hebben begrepen. Hij probeert “Eligible Person for Societal Integration” op te bouwen met verschillende “rollen” als onderdelen: “Belgian National”, “EU Citizen”, “Foreigner”, “Stateless”, “Refugee”… Dit ongetwijfeld omdat deze mogelijkheden verschijnen in Art.3, 3° lid, van de wet. In OpenFisca is een groepsentiteit echter samengesteld uit Personen die elk een rol krijgen. Een Household bevat zo Adult en Child rollen. Het is vrij nonsensicaal dat een EligiblePerson meerdere Foreigners zou kunnen bevatten. Nationaliteit of herkomst, of andere voorwaarden die gesteld worden in deze wet, zijn ook hier variabelen die gebonden zijn aan de persoon, geen entiteit op zich.

Op een ander moment werd nog een aparte entiteit gecreëerd voor het OCMW. Hoewel het logisch lijkt om de OCMWs te modelleren en als een entiteit te beschouwen – ze worden immers vermeld in de wet – is het dat hier (nog) niet. Er zijn immers geen verschillende types OCMWs met verschillende eigenschappen of rollen, waarvoor we telkens andere berekeningen moeten maken. In de context van deze wet, waarbij het de burger is voor wie we het recht op maatschappelijke steun berekenen, is het OCMW vooral een constant, invariant gegeven. In OpenFisca kunnen we dat dus vooralsnog overslaan. (Een entiteitstype “instituut” is ook niet voorzien.)

We merken hier dus dat Cursor niet “nee” kan antwoorden op de vraag of er nuttige andere entiteiten kunnen toegevoegd worden. Het kan de denkrichting achter die vraag niet bekritiseren of corrigeren uit eigen beweging. Doorheen het hele experiment bleken Cursor en GPT-5 ook een neiging te vertonen tot onnodige complexiteit. Dit is voor developers die met onbekende code of frameworks werken een groot risico: indien men te snel te ver meegaat met zulke suggesties, dreigt men later de pedalen te verliezen en achteraf erg moeilijke correcties te moeten aanbrengen aan de fundamenten van het project. Eens een verkeerde route is ingeslagen, blijkt het ook moeilijk om op de stappen terug te keren en deze weer te doen vergeten. Zeker als men ze eerst onwetend heeft toegelaten, komen ze terecht in de context en wordt er in vervolgvragen op verdergebouwd. Deze sluipende “context rot” is ondertussen een bekend probleem en een belangrijke oorzaak van tijdverlies met AI-enabled coding.

Variabelen

De kern van het model zit in de variabelen die de rechten en voorwaarden uit de wet voorstellen. Artikel 2 van de wet somt de verschillende vormen van maatschappelijke integratie op waarop iemand recht kan hebben (o.a. tewerkstelling, leefloon, geïndividualiseerd project). Artikel 3 bevat de voorwaarden waaraan een persoon moet voldoen om van dat recht gebruik te maken. We hebben deze bepalingen stap voor stap in code omgezet.

Recht op maatschappelijke integratie betekent in de praktijk dat een OCMW een persoon moet ondersteunen via (1) een job of opleiding, (2) een leefloon, of (3) een geïndividualiseerd project voor maatschappelijke integratie. Dit kan vertaald worden naar drie boolean variabelen op de Persoon-entiteit, bijvoorbeeld employment_right, living_wage_right en individualized_project_right. Cursor geeft hier een goede code-suggestie, en voorziet een eenvoudige placeholder-formule: zolang iemand “in aanmerking komt voor integratie” (een andere variabele) zou het recht gelden. We bekomen een definitie van employment_right als volgt:

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

class employment_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  def formula(person, period, parameters):
    return person("eligible_for_integration", period)

De invulling van deze placeholder-formule komt aan bod in het daaropvolgende Artikel 3. Die modelleert de volgende voorwaarden om in aanmerking te komen:

• Verblijf in België (volgens de regels nader te bepalen bij KB).
• Leeftijd: De persoon is meerderjarig (18+), of als minderjarige gelijkgesteld aan een meerderjarige volgens de uitzonderingen in deze wet.
• Nationaliteit of verblijfsstatuut: De persoon is Belg, EU-burger (na 3 maanden verblijf), ingeschreven vreemdeling, staatloze, vluchteling of subsidiair beschermde.
• Onvoldoende bestaansmiddelen
• Werkbereidheid (tenzij onmogelijk om gezondheidsredenen of billijkheidsredenen).
• Rechten uit andere stelsels uitgeput

Al deze voorwaarden komen samen in één centrale boolean variabele societal_integration_right. Die variabele geeft aan of iemand, gegeven zijn persoonlijke situatie, recht kan hebben op maatschappelijke integratie. In feite is dit de vertaalslag van “voldoet de persoon aan alle voorwaarden van art.3?”. De formule combineert alle subvoorwaarden:

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

class societal_integration_right(Variable):
  value_type = bool
  entity = Person
  definition_period = MONTH
  label = "Right to societal integration"
  def formula(person, period, parameters):
    residency = person("residency_status", period)
    is_major = person("is_major", period)
    nationality = person("nationality_status", period) in ["belgian", "eu_citizen", "registered_foreigner", "stateless", "refugee"]
    insufficient_income = not person("has_sufficient_income", period)
    willing_to_work = person("willing_to_work", period)
    claiming_benefits = person("claiming_benefits", period)
    return (residency and is_major and nationality and insufficient_income and willing_to_work and claiming_benefits)

Let hier vooral op enkele vreemde lacunes in de suggestie van Cursor. Zo is de naam van de variabele societal_integration_right niet gelijk aan de eerder gedefinieerde placeholder eligible_for_integration, hoewel dat wel de bedoeling is. Daarnaast wordt in de nationaliteitsvoorwaarde de mogelijkheid van subsidiair beschermden simpelweg vergeten! Tot slot is de zesde voorwaarde, dat men eerst zijn rechten laat gelden op eventuele sociale uitkeringen, wel erg rudimentair benoemd als claiming_benefits – een variabelenaam die niet echt dekt wat bedoeld wordt.

We kunnen deze suggestie dus wel aanvaarden, maar we zijn al direct verplicht om 3 correcties door te voeren. De niet-overeenkomst van de variabelenaam kunnen we daarbij nog gemakkelijk detecteren omdat de tests niet zullen werken als er nog ongedeclareerde variabelen in de code zitten. Een mankerend element in de formule, zoals een vergeten voorwaarde, is echter veel gemakkelijker over het hoofd gezien, en leidt wanneer dat ongedetecteerd blijft gegarandeerd tot fouten in de uitvoering. Hier merken we dus echt wel de noodzaak om terug te koppelen naar de wettekst om te verifiëren dat de gegenereerde code wel degelijk overeenkomt met wat de wettekst zegt. Deze terugkoppeling moet aandachtig genoeg gebeuren om ook ongelukkige benamingen of subtiele misinterpretaties van te tekst te kunnen identificeren.

Eventuele correcties kunnen daarnaast ook best zo snel mogelijk gebeuren. Als foutieve code in de editor aanwezig blijft, gaat ze immers deel uitmaken van de context die het AI-model gebruikt en dient ze zelf als fundament voor daaropvolgende suggesties. Dit kan leiden tot een situatie waarbij men suggesties blijft ontvangen waarin steeds dezelfde fouten terugkomen, die men dus ook telkens weer moet corrigeren, wat niet bevorderlijk is voor de productiviteit.

De variabelen gebruikt in de formula() methode van societal_integration_right hierboven, moeten uiteraard op hun beurt ook gedefinieerd worden: voor elk van deze variabelen moeten we een klasse schrijven. Dit kan aanleiding geven tot complexe kettingen van afhankelijkheden. Zo zou is_major een eenvoudige booleaanse inputvariabele kunnen zijn, maar we kunnen dat ook berekenen op basis van de datum van vandaag en weer een nieuwe variabele birthdate. De berekening van de formule van de variabelen kan daarnaast ook gebruik maken van de parameters van een wet – zo is de meerderjarigheid in België pas vanaf 18 jaar sinds 1 mei 1990. Dat zou ons dan weer bij het Burgerlijk Wetboek brengen, en haar geschiedenis – om het beknopt te houden gaan we daar nu niet verder op in.

Laatste opmerking: het model zoals hier gebouwd is uiteraard een vereenvoudigde weerspiegeling. Merk wel op dat we zelfs dan, slechts 3 artikels ver in een wet, al snel 10 Python-klassen hebben gedefinieerd hebben, met potentieel voor meer als we echt in de diepte zouden willen gaan. Cursor en GPT-5 schrijven daarbij relatief verbose code, met vele hulpvariabelen en -methodes, die soms echt wel eenvoudiger kan. Sommige details uit de wet, zoals de 3-maanden wachttijd voor EU-burgers, of de uitzonderingen die bestaan voor bepaalde categorieën van minderjarigen (Art. 7), zouden in een volwaardig model nog heel wat extra variabelen of condities vergen.

AI en code: enkele valkuilen

Wat betreft best practices voor de inzet van AI-hulp bij zulke projecten, identificeren we nog enkele valkuilen, naast diegene die we tot nu toe al genoemd hebben.

Teveel documentatie toevoegen in het begin leidt snel tot “context confusion“, waarbij de suggesties of de antwoorden van de LLM gebaseerd gaan zijn op stukken informatie die (nog) niet relevant zijn. Het is beter de documentatie geleidelijk toe te voegen, in gelijke tred met de functionaliteit, in plaats van de volledige analyse en achtergrond op voorhand toe te voegen aan de IDE. In het geval van regelgeving: voeg de regels artikel per artikel toe aan de IDE, naarmate de projectontwikkeling vordert, en weersta de verleiding om de hele wettekst op voorhand als “encyclopedische referentie” te integreren in de IDE.

Context rot of context poisoning ontstaat dan weer wanneer de AI een verkeerde weg is ingeslagen,  daarop voortboomt, en uiteindelijk relevantere informatie vergeet zodat het ook moeilijker wordt om ervan te herstellen. “Context quarantining“, het opdelen van het probleem in kleinere deelproblemen elk met hun eigen context, is daarvoor een logische remedie. Dit is ook de weg die de meeste “deep research” of “multi-agentic” systemen inslaan. In een IDE zou dat impliceren dat een AI-systeem de codebase en de documentatie vanaf een zekere grootte zou moeten segmenteren. Hoe dat technisch uitgewerkt kan worden achter de schermen lijkt een uitdaging van formaat, en verschillende IDEs zullen daar in de nabije toekomst waarschijnlijk hun eigen approach voor ontwikkelen.

Een andere frustratie was dat de AI soms code of bestanden verkeerd plaatste of aannam dat bepaalde dingen bestonden. Zo refereerden gegenereerde formules naar variabelen die nog helemaal niet gedefinieerd waren. Dit zorgt bij het testen natuurlijk voor foutmeldingen. We moesten de AI dan bijsturen of zelf extra variabelen invoegen om die referenties af te dekken. Ook kleine zaken, zoals de formattering van documentatie of het wel/niet aanmaken van noodzakelijk imports, vergden manuele correctie. Dit soort inconsistenties tonen aan dat je AI-suggesties niet blindelings kunt vertrouwen. Een developer moet voortdurend valideren of de code die gegenereerd wordt strookt met de bedoeling, en zo niet, onmiddellijk ingrijpen.

publi.codes

We willen ook nog wijzen op het bestaan van publi.codes als eventueel alternatief voor OpenFisca. Recenter en moderner, moeten de regels daar gecodeerd worden in een YAML-formaat, wat veel hanteerbaarder is dan het schrijven van subklassen in Python, en veel leesbaarder voor niet-developers. Men is in ruil daarvoor echter wel beperkt tot de bewerkingen die zijn toegelaten door de achterliggende motor. Pas vanaf de nog in ontwikkeling zijnde versie 2 komen daar mogelijkheden bij om barema’s te encoderen, of abattementen (vrijgestelde bedragen), die in België erg veelvuldig voorkomen.

De huidige versie van publi.codes is bovendien afhankelijk van het NPM ecosysteem dat tegenwoordig regelmatig geplaagd wordt door supply chain aanvallen. Publi.codes v2 zou dan weer gecompileerd worden naar OCaml, een programmeertaal die we bij Smals niet gebruiken. Gezien de kans klein is dat Smals deze programmeertaal zou willen introduceren in haar portfolio (en een ondersteunend team ervoor zou willen uitbouwen), leek het weinig nuttig om voor deze oefening ook publi.codes in de diepte te bekijken. Het valt echter wel op dat op het vlak van UI-componenten, publi.codes wel enkele libraries heeft klaarliggen.

Conclusie

Zowel OpenFisca als publi.codes zijn als platform vooral sterk wanneer je regels kunt modelleren als expliciete, testbare berekeningen. Minder ideaal is het voor regels die vooral draaien op discretionaire beslissingen, vrije interpretatie, bewijswaardering, uitzonderingen zonder heldere parameters, of “case management”-workflows. Het zijn primair reken- en regelsystemen, geen dossierbehandelingsplatformen. Daarmee zijn ze eventueel wel geschikt als motor voor apps die belastingen of uitkeringen op niveau van persoon/huishouden kunnen berekenen (recht op iets + bedrag), of om beleidsimpact te simuleren van eventuele wijzigingen (“wat kost deze hervorming?”, “wie wint/verliest?”). Dat kan voor beleidsmakers én burgers interessant zijn.

Toch is een OpenFisca-project niet snel even opgezet. Conceptueel is OpenFisca enigszins verwarrend voor een developer: hoewel OpenFisca gebruikmaakt van Python-klassen, dienen deze niet om objecten te modelleren, maar om entiteiten, variabelen en berekeningsregels uit de regelgeving declaratief vast te leggen. Gegeven dat er 1 klasse per variabele moet geschreven worden, en er vlotjes tientallen variabelen kunnen meespelen in een fijnmazig wetsartikel, zit men met een snel groeiende stapel code die een uitdaging is om overzichtelijk georganiseerd te krijgen. Daarnaast vergt ook de ontwikkeling van een GUI veel extra werk. Het project mist nog de nodige tooling om deze recurrente problematieken te verlichten. (Het helpt natuurlijk niet wanneer de opdrachtgevende overheid in 2020 plots de kraan dichtdraait, schijnbaar van mening dat open-source projecten per definitie zelfbedruipend kunnen zijn.)

Tot slot kunnen we nog zeggen dat dit experiment tegelijk een nuttige en leerzame reality check was over wat LLMs kunnen bijdragen, en kunnen verknoeien, aan een developer-werkomgeving. Zelf de regie stevig in handen blijven houden en werken met kleine incrementele stapjes, blijft de beste raad. De ene AI tool zal daarbij al wat minder steken laten vallen dan de andere op allerlei vlakken. Het geven van negatieve antwoorden of het detecteren van fouten in de vraagstelling blijft erg uitdagend voor LLMs en dat brengt wat risico met zich mee. AI-assistentie in IDEs evolueert echter razendsnel, en een gelijkaardig experiment zal volgend jaar ongetwijfeld anders verlopen.

Rules As Code betekent zeker niet dat we vandaag een wettekst aan een AI kunnen geven om er een programma te laten uitrollen. Wel zal er op gespecialiseerde fora de komende jaren ongetwijfeld veel aandacht gaan naar de interactie tussen wet, implementatie, en AI-tooling. Vooralsnog blijft de complexiteit van de regelgeving zelf, ook met steeds betere AI, de grootste hinderpaal voor Rules As Code projecten.

(FR) Dans ce Research Talk (en Néerlandais, sous-titres FR sont disponibles), Joachim Ganseman, chercheur chez Smals, est interrogé sur ses expériences avec les systèmes « Rules as Code » (RaC) et leur mise en œuvre au sein du domaine — complexe — de la sécurité sociale. Joachim émet quelques réserves quant à l’applicabilité directe de ces systèmes dans notre contexte. Regardez et écoutez ici pourquoi.

(EN) In this Research Talk (Dutch speaking, EN subtitles available), Joachim Ganseman, researcher at Smals, is interviewed about his experiences with “Rules as Code” (RaC) systems and their implementation within the complex domain of social security. Joachim places some reservations regarding the direct applicability of these systems in our context. Watch and listen here to find out why. 

Sauf indication contraire, cet article fait référence à la législation belge en vigueur au 15 octobre 2025. Les interprétations des textes législatifs dans cet article sont fournies à titre indicatif uniquement et ne font en aucun cas autorité.

Dans une utopie administrative, le parlement vote une loi ou le gouvernement prend une décision qui modifie quelque chose, et le logiciel utilisé pour sa mise en œuvre pratique peut être adapté presque automatiquement à la modification. Le concept d’un lien étroit entre la réglementation et sa mise en œuvre logicielle est également connu sous le nom de Rules as Code, ou RaC.

Au départ, il a surtout été exploré dans le monde juridique, dans les milieux universitaires, dans les incubateurs du secteur, parmi les professionnels du droit ou chez les innovateurs intéressés par la LegalTech. Un nouvel élan est apparu en 2020 lorsque l’OCDE a publié un rapport volumineux dans lequel elle fait le point sur la situation du point de vue des pouvoirs publics, en se référant à des preuves de concept provenant de différents pays. Cela venait à point nommé, car la pandémie de COVID-19 cette même année avait confronté les gouvernements et leurs fournisseurs informatiques à des directives et des mesures en constante évolution à mesure que les connaissances scientifiques sur la maladie progressaient, et à une pression temporelle sans précédent pour mettre en œuvre chaque update le plus rapidement possible. Une technologie capable de faciliter la mise en œuvre harmonieuse de nouvelles réglementations est donc la bienvenue.

Certains pays sont donc passés à la vitesse supérieure. La France est en tête en matière de preuves de concept fonctionnelles, notamment avec les simulateurs Mes Droits Sociaux, LexImpact et divers projets basés sur des publicodes. Des initiatives sont également en cours au Canada, en Australie, en Nouvelle-Zélande et aux Pays-Bas. L’UE a publié un article thématique informatif sur sa plateforme GovTech Connect, mentionnant plusieurs autres sources, et aux États-Unis également, des voix s’élèvent pour attirer l’attention sur ce sujet. Enfin, une étude néerlandaise approfondie nous fournit un aperçu pratique et récent des solutions Rules as Code.

Domaines d’application

Ce serait bien de pouvoir convertir une loi de manière semi-automatique en un logiciel (de préférence correct). Cependant, les expériences menées en Nouvelle-Zélande nous ramènent à la réalité et démontrent de manière convaincante qu’une correspondance parfaite entre la loi et le logiciel correspondant, si tant est qu’elle soit réalisable, est même indésirable dans de nombreux cas.

L’application des règles nécessite en effet une interprétation. Ainsi, la formulation de nombreuses lois est délibérément maintenue quelque peu abstraite, afin de les rendre largement applicables ou d’éviter que des lacunes n’apparaissent trop rapidement lorsque la société évolue. Pour chaque application pratique, ces concepts abstraits doivent être concrétisés. Ce n’est pas toujours facile : quand les petites réparations d’une maison louée sont-elles “de nature structurelle” (et donc à la charge du propriétaire) ? Quand les mesures RGDP sont-elles “suffisantes” ? Une dépense est-elle ou non une “dépense professionnelle déductible” ? Et qui sont exactement ces vagues “autorités compétentes” auxquelles le texte de loi fait référence ? Tout cela fait l’objet de discussions.

Les circulaires ou les décisions administratives permettent parfois aux autorités publiques de clarifier l’interprétation souhaitée, mais il est rare d’aboutir à un ensemble complet et cohérent de règles. En cas d’ambiguïté, une différence minime d’interprétation peut faire toute la différence. Si nous imaginons une conversion entièrement automatique du texte de loi en logiciel, nous risquons de sauter ces étapes d’interprétation ou de les laisser remplir sans beaucoup de finesse par des valeurs par défaut préprogrammées. Tout juriste frémirait à cette idée, et à juste titre.

Rules as Code n’est donc pas la panacée et trouve surtout des applications lorsque les règles sont sans ambiguïté et ne nécessitent que peu d’interprétation, ou lorsque les imprécisions sont acceptables et peuvent être conservées dans le résultat final. L’exemple classique est un ensemble de règles qui peuvent être réduites à un arbre de décision basé sur des critères objectivement calculables. Les applications associées sont, par exemple, les formulaires de demande, les simulateurs ou les modules de calcul. Les réglementations de nature plutôt normative, telles que les règlements de l’UE qui utilisent fréquemment des termes vagues tels que “suffisant”, “adéquat”, “approprié”, “pertinent”, etc. ne s’y prêtent pas, ce que certains universitaires ont judicieusement formulé ainsi : “la justice ne peut être automatisée“.

Obstacles

Dès que l’on commence à transposer la réglementation en code, on se heurte rapidement à la complexité des liens internes entre toutes sortes de lois et de décisions. Un bon exemple est l’âge de la retraite aux Pays-Bas : bien que défini de manière assez simple à l’article 7a de la loi concernée, il affecte ou est cité dans au moins 100 autres lois ou statuts néerlandais. Si l’on y touche, on risque donc rapidement de provoquer un effet domino important.

En outre, le législateur fait preuve de créativité lorsqu’il s’agit de trouver des solutions à certaines situations rares. Il est courant de revoir ou d’élargir les définitions, ou d’ajouter des exceptions ou des conditions supplémentaires. Chaque amendement peut à son tour renvoyer à d’autres règles ou lois, ce qui entraîne toute une série de dépendances.

Prenons le concept de majorité. En théorie, c’est une règle simple : toute personne âgée de 18 ans ou plus est majeure et donc capable d’exercer ses droits civils (art. 488 de l’ancien Code civil). Cependant, ce tout petit article est suivi d’une série d’articles beaucoup plus longs sur les exceptions à cette règle (art. 488/1 et suivants), jusqu’à l’administration (art. 494–502). Si cela ne suffit pas, le juge de paix peut également intervenir (art. 492) et statuer sur une longue liste de capacités qui, au moment de la rédaction du présent document, comprend déjà 42 éléments distincts (art. 492/1 §2 + §3) .

Supposons qu’un service public soit autorisé à octroyer des subventions sur la base d’un règlement qui impose la majorité comme condition et que nous souhaitions créer un site web permettant aux citoyens de vérifier leur éligibilité. Dans ce cas, programmer if (x≥18) n’est pas toujours suffisant. Une personne sous tutelle qui n’est pas autorisée à gérer ses propres finances peut devoir obtenir une autre réponse. Cela n’est pas nécessairement explicitement mentionné dans le règlement relatif aux subventions, mais découle de l’application de la définition de la majorité civile telle qu’elle figure dans le code civil.

Mais ce n’est pas tout : les lois peuvent étendre ou modifier les définitions antérieures. Ainsi, le concept de majorité est élargi dans la loi sur l’intégration sociale : les personnes mineures mariées, enceintes ou ayant des enfants à charge sont assimilées à des personnes majeures (art. 7), mais uniquement pour l’application de cette loi. En résumé : toute personne majeure a plus de 18 ans, mais toutes les personnes âgées de plus de 18 ans ne sont pas pleinement indépendantes, et la notion de majorité peut en outre varier selon le domaine d’application.

L’aspect temporel introduit une dimension de complexité supplémentaire. En effet, toutes ces règles n’ont pas toujours été en vigueur. En Belgique, la majorité à 18 ans n’est entrée en vigueur que le 1er mai 1990 (loi du 19 janvier 1990, publiée au Moniteur belge le 30 janvier 1990). Auparavant, il fallait avoir 21 ans. La tutelle générale mentionnée ci-dessus a été précédée par différents statuts spéciaux, dont la “minorité prolongée” et la “tutelle provisoire”. Ces derniers ont été supprimés en 2014, mais en raison d’une disposition transitoire, ils n’ont disparu dans la pratique que le 1er septembre 2019. Des changements surviennent également en raison de fusions communales, de réformes de l’État, de pays qui n’existent plus, de règles temporaires telles que les mesures de soutien COVID, etc.

Même si une ancienne législation a été abrogée depuis des années, ses effets peuvent encore se faire sentir longtemps. Nous voyons ainsi sur notre déclaration d’impôts de 2025 une déduction pour “cotisations spéciales de sécurité sociale des années 1982 à 1988” (cadre VIII, code 1388-67). Les droits sociaux acquis dans le cadre de statuts ou de régimes qui n’existent plus aujourd’hui continuent également de compter. Si un calcul dépend d’une situation passée et de la législation en vigueur à l’époque, il peut donc être nécessaire d’implémenter dans un logiciel non seulement la réglementation actuelle, mais aussi tout son historique.

Toute cette complexité, même dans des concepts simples, ne peut que donner lieu à des lacunes ou des incohérences. Le Conseil d’État a fort à faire pour conseiller le législateur et corrige régulièrement les erreurs dans les projets de texte. Même dans ce cas, le Moniteur belge doit souvent publier des errata. Le gouvernement est parfois chargé de définir les détails du contenu, mais les arrêtés royaux ou ministériels se font attendre, ce qui crée un vide pendant un certain temps. D’autres fois, la formulation n’est pas assez précise : par exemple, on ne précise pas s’il s’agit de jours calendaires ou de jours ouvrables.

Lorsque des lacunes, des contradictions apparentes ou des interprétations donnent lieu à des discussions, la Cour de cassation doit parfois clarifier certaines choses. Bien que cela ne garantisse pas une réduction de la confusion linguistique à l’avenir, comme en témoigne ce récent arrêt dans lequel il est précisé qu’un véhicule à moteur au sens de la loi sur la circulation routière ne doit pas être compris comme un véhicule à moteur tel que défini dans le code de la route…

Enfin, il existe des cas où le texte de loi lui-même est grammaticalement ambigu. Ainsi, dans l’arrêté d’exécution du Gouvernement de la Région de Bruxelles-Capitale relatif aux travaux exemptés de permis d’urbanisme, il est mentionné à l’article21/1, 3° : “[…] la pose d’isolation […] sur un mur mitoyen ou une façade non visible depuis l’espace public […]”. Il n’est pas clair ici si la phrase subordonnée (“non visible depuis l’espace public”) se rapporte uniquement à la façade ou à la fois à la façade et au mur mitoyen. Sans doute au grand dam de homegrade.brussels, qui doit conseiller les particuliers à ce sujet et qui doit admettre dans sa fiche d’information sur le sujet : “Cet article est sujet à diverses interprétations”.

Cela représente déjà un défi de taille dans le cadre du développement d’applications classiques. La tâche serait-elle plus simple si nous construisions notre application autour d’un framework Rules as Code ? Pas vraiment : un framework RaC peut fournir une méthodologie ou une approche fixe, mais cela ne suffit pas à éliminer la complexité : la même quantité d’informations doit toujours être programmée, et les ambiguïtés continuent de poser les mêmes problèmes. Certains moteurs RaC permettent de détecter les lacunes dans les règles, mais il faut encore décider quoi en faire. Bien définir le projet et fixer des limites reste nécessaire pour éviter d’être submergé par une avalanche de dépendances, de références et d’historique des modifications.

La base : l’analyse législative

Supposons que nous voulions créer un logiciel qui mette en œuvre une certaine législation et qui calcule, par exemple, si vous avez droit à une subvention spécifique et, si oui, à quel montant.

Tout d’abord, il faut trouver un moyen de convertir cette loi en une forme structurée qui facilite la conversion en code. Grâce à une analyse législative, nous essayons de décomposer chaque règle de cette loi en ses différents éléments. Le schéma d’analyse ci-dessous, provenant du ministère néerlandais de l’Intérieur, est générique et prévoit une division en 15 classes :

Les variables sont des caractéristiques qui peuvent varier pour chaque sujet de droit (personne ou entité) : pour une personne, il s’agit par exemple du sexe, du lieu de résidence, du nom, de l’état civil. Les paramètres, en revanche, sont les caractéristiques de la règle qui sont identiques pour tout le monde : un champ d’application, une date de début, une valeur d’indice, etc. Ainsi, une circulaire aura souvent pour objectif d’adapter des paramètres tels que la valeur de l’indice, tandis qu’une loi définira quelles variables peuvent être prises en compte dans l’application d’une règle et dans quelles conditions. Il est parfois difficile de déterminer si un terme relève des variables ou des paramètres. Les créateurs de cette méthode fournissent pour chaque catégorie une description et des exemples qui clarifient la manière dont ils peuvent être exprimés dans un texte législatif.

Prenons l’exemple du droit au congé de maternité, régi par le chapitre IV, art.39 et suivants de la loi sur le travail. En résumé, la règle de base est qu’une femme enceinte a droit à ce congé à partir de 6 semaines avant la date prévue de l’accouchement estimée par le médecin (8 semaines en cas de grossesse multiple), plus 9 semaines après l’accouchement. Une analyse rudimentaire de cette règle selon le schéma ci-dessus peut être commencée comme suit :

• La femme, son employeur et son médecin sont tous des sujets de droit, liés entre eux par une relation de travail ou une relation médecin-patient qui sont des relations juridiques.
• L’une des conditions de cette loi est que la date de l’accouchement soit estimée par un médecin dans un certificat médical remis à l’employeur. Ce certificat est ici un objet juridique.
• Les variables applicables à la femme sont notamment : le nombre d’enfants qu’elle attend, son lieu de résidence, son lieu de travail, la date prévue pour l’accouchement… Elles sont différentes pour chaque femme.
• Les paramètres de cette loi sont notamment les délais minimaux et maximaux mentionnés : 6 semaines, 8 semaines, 9 semaines… Ils sont identiques pour toutes les femmes.
• L’indication de la durée et du lieu précise où et quand la règle s’applique : sur le territoire belge, et depuis les dernières modifications législatives, c.à.d. à partir du 1er juillet 2004 pour la partie prénatale et du 1er mars 2009 pour la partie postnatale du congé de maternité. L’historique des paramètres peut également être consigné. Les variables peuvent également comporter des indications temporelles si elles évoluent dans le temps.

La réglementation effective prévoit notamment des situations exceptionnelles pour les enfants prématurés, malades ou mort-nés, etc. En tenir compte dans l’analyse peut conduire à l’ajout de nombreux paramètres et variables supplémentaires afin de couvrir toutes ces exceptions.

La règle de déduction prend alors la forme d’un calcul, dans lequel :

• l’input consiste en une “situation” décrite comme un ensemble de variables,
• les conditions permettent d’activer ou non certains composants du calcul,
• les paramètres donnent un poids aux composants du calcul,
• l’output peut être une valeur catégorielle ou numérique,
• le calcul peut s’appuyer sur d’autres règles de déduction avec leurs propres paramètres, conditions et variables.

Nous sommes libres de choisir le niveau de granularité ou la profondeur de notre analyse. Nous pouvons pinailler et essayer d’encoder chaque détail de la réglementation, mais nous pouvons tout aussi bien nous contenter de faire quelques généralisations, ne serait-ce que pour éviter que le logiciel final ait plus de boutons qu’un cockpit d’avion. Nous avons donc pris la femme comme point de départ ci-dessus, mais en réalité, la loi parle d’employée. Cela implique un contrat de travail valide. Nous pouvons intégrer cela avec des variables et des conditions supplémentaires, et même avec des règles supplémentaires sur les contrats de travail, mais cela apporte-t-il une valeur ajoutée ? Il peut suffire de laisser les choses telles quelles et d’indiquer dans une clause de non-responsabilité que l’application ne s’applique qu’aux employées.

Traduire correctement la législation en code n’est donc pas chose aisée et nécessite de prendre en compte certains éléments. Il est utile à cet égard d’établir une collaboration étroite entre les juristes, qui peuvent expliquer clairement les règles, et les développeurs de logiciels qui doivent les traduire en code informatique, avec ou sans approche RaC. Il en résulte également de nouveaux profils combinant des compétences juridiques et techniques : nous assistons progressivement à l’émergence de “legal engineers” et de “programmateurs politiques”. 

L’approche Rules as Code

L’objectif d’une approche Rules as Code est de traduire les lois, les règles, les politiques, etc. dans un format structuré compréhensible par une machine. Cela peut ensuite être directement intégré dans des applications ou des sites web. L’idée est que ces applications puissent ainsi être plus facilement adaptées à une réglementation en constante évolution et que les utilisateurs puissent compter sur une plus grande transparence grâce au lien direct avec la législation.

Il n’existe pas de normes internationalement reconnues pour l’analyse législative, ni pour l’encodage des textes législatifs. L’exemple néerlandais ci-dessus est applicable de manière générique, mais cette initiative est encore jeune. Les moteurs Rules as Code existants utilisent d’autres conventions, qui peuvent varier considérablement les unes des autres. Ils définissent généralement leur propre encodage, sous la forme d’un Domain-Specific Language ou d’un Controlled Natural Language, dans lequel la réglementation doit d’abord être convertie. Ce n’est qu’une fois cette étape franchie que d’autres applications peuvent être développées.

L’absence de formats, de modèles et d’ontologies standardisés rend difficile l’adoption de Rules as Code. Entre les différents preuves de concept dans différents pays, parfois même au sein d’un même pays, l’interopérabilité reste encore assez faible. Chaque pays ou chaque département risque ainsi d’utiliser son propre langage, approche ou méthodologie, ce qui entraîne une fragmentation et une duplication des efforts. Idéalement, il faudrait viser un vocabulaire standardisé et des règles publiées dans un format uniforme, afin qu’elles puissent être réutilisées et échangées entre différents systèmes et services publics.

Parmi les outils Rules as Code existants d’une certaine importance, on trouve OpenFisca, PubliCodes, Català et RegelSpraak. Nous nous tenons délibérément à distance des BPMN, CMMN, langages de programmation logiques et rule engines classiques, qui ne sont pas adaptés aux textes juridiques. Dans un prochain article, nous approfondirons notre analyse en nous focalisant sur les outils spécialement conçus pour la législation, et nous en choisirons un pour l’étudier en détail sur le plan technique.

Conclusion provisoire

Les frameworks Rules as Code fournissent une méthode uniforme et générique pour analyser la législation. Ils offrent aux programmeurs une bibliothèque contenant les éléments de base nécessaires pour mettre en œuvre la réglementation et créer des scénarios de test, quel que soit le domaine dans lequel ils travaillent. En analysant la réglementation et en la convertissant en un domain-specific language, celle-ci peut être traitée par un rule engine ou un interpreter. Il est important de noter que cette conversion nécessite pour l’instant un travail humain minutieux et analytique, car elle implique une interprétation. (L’externalisation de cette étape à de grands modèles de langage ne donne pas de résultats entièrement positifs, mais nous y reviendrons dans un prochain article).

Le niveau de détail de nombreuses réglementations rend l’analyse et la conversion vers un format Rules as Code rarement aisée. Si l’on souhaite aboutir à un système complet et cohérent qui tienne compte de nombreuses dépendances et situations exceptionnelles, on se retrouve confronté à une quantité impressionnante de paramètres et de variables. Si les calculs doivent pouvoir être rétroactifs et que l’historique de la législation joue également un rôle, cela ajoute une dimension supplémentaire. Les interdépendances internes entre toutes les règles font que, pour mettre en place une application Rules as Code, il faut rapidement s’attendre à un effort initial important.

L’un des arguments en faveur du Rules as Code est qu’il permettrait de développer certains types d’applications de manière générique pour n’importe quel domaine : eligibility checkers, compliance tools, tax/benefit calculators, formulaires web, simulateurs de calcul, gestion de dossiers, etc. Tant que la législation sous-jacente est suffisamment claire et concrète, une même application template pourrait être utilisée sans trop de modifications dans tous les départements gouvernementaux. Cette idée louable se heurte toutefois à des difficultés pratiques liées à la législation elle-même, qui se réinvente presque dans chaque domaine : il est ainsi difficile de développer des composants communs pour la majorité ou les véhicules à moteur lorsque ces termes ont des définitions différentes dans différentes lois.

Une autre promesse de Rules as Code est que les applications développées sur la base de tels frameworks restent étroitement liées à la législation, ce qui peut également être rendu visible. Ce lien doit offrir des garanties plus transparentes qu’une application est bien conforme à la législation et qu’elle le restera si cette législation venait à changer demain. En outre, il existe un potentiel pour aider à l’élaboration de règles. Un processus itératif dans lequel une version RaC des règles est élaborée parallèlement à la version préliminaire du texte peut permettre de détecter et de combler rapidement les lacunes, voire de faciliter l’analyse politique ex ante en simulant d’abord l’impact de modifications législatives hypothétiques (voir également le rapport de l’OCDE à ce sujet). Il n’en reste pas moins que, même avec le framework RaC, la mise en œuvre de ce processus nécessite les mêmes investissements importants.

Pour rassurer ceux qui craignent que les ordinateurs ne prennent bientôt le contrôle du système judiciaire, nous en sommes encore très loin. Rappelons également que le RGPD, dans son article 22, fixe des limites claires à la prise de décision automatique. En outre, une version codifiée d’une loi n’a pour l’instant aucun statut juridique ni aucune validité légale : seul le texte original de la loi est contraignant. En d’autres termes, même si nous convertissons la réglementation en code, le contrôle humain reste indispensable et le Moniteur belge a toujours le dernier mot.

Affaire à suivre…

Noot: dit artikel refereert naar Belgische wetgeving zoals deze gold op 15 oktober 2025, tenzij waar anders aangeduid. De interpretaties van wetteksten in dit artikel dienen slechts ter illustratie en zijn in geen geval autoritatief.

In een administratief utopia stemt het parlement een wet, of neemt de regering een besluit, dat iets wijzigt, en kan de software gebruikt voor de praktische uitwerking ervan haast automatisch aangepast worden aan de wijziging. Het concept van een nauwe koppeling tussen regelgeving en de softwarematige implementatie ervan, staat ook bekend onder de naam Rules as Code, afgekort RaC.

Initieel werd het vooral verkend in de juridische wereld, in academia, in incubatoren in de sector, onder juridische professionals, of bij innovatoren met interesse in LegalTech. Een hernieuwd elan kwam er in 2020 toen de OESO een lijvig rapport publiceerde waarin ze een stand van zaken geeft vanuit overheidsperspectief, daarbij refererend naar proof-of-concepts uit verschillende landen. Goed getimed, want de COVID-pandemie in datzelfde jaar had overheden en hun IT-leveranciers geconfronteerd met snel wijzigende richtlijnen en maatregelen naarmate de wetenschappelijke kennis over de ziekte toenam, en een ongeziene tijdsdruk om elke update zo snel mogelijk in de praktijk om te zetten. Technologie die een soepele implementatie van nieuwe regulering kan faciliteren, klinkt dan als muziek in de oren.

Sindsdien zijn enkele landen dan ook een versnelling hoger geschakeld. Frankrijk loopt op kop wat betreft werkende proof-of-concepts, waaronder simulatoren op Mes Droits Sociaux, LexImpact, en verscheidene projecten gebaseerd op publicodes. Ook in Canada, Australië, Nieuw-Zeeland en Nederland lopen er initiatieven. De EU publiceerde een informatief thema-artikel op haar GovTech Connect platform met vermelding van verschillende andere bronnen, en ook in de VS gaan stemmen op om er aandacht aan te besteden. Een diepgaande Nederlandse studie tenslotte voorziet ons van een handig en recent overzicht van Rules as Code oplossingen.

Toepassingsdomein

Het klinkt mooi om een wet semi-automatisch te kunnen omzetten in (liefst correcte) software. Ervaringen uit Nieuw-Zeeland zetten ons echter met de voeten op de grond en tonen overtuigend aan dat een 1-op-1 mapping tussen wet en bijhorende software, als dat al haalbaar is, in veel gevallen zelfs onwenselijk is.

De toepassing van regels vereist immers interpretatie. Zo wordt de verwoording van veel wetgeving met opzet enigszins abstract gehouden, om ze breed toepasbaar te maken, of om te voorkomen dat er te snel mazen ontstaan wanneer de samenleving evolueert. Voor elke praktische toepassing moeten die abstracte concepten concreet ingevuld worden. Dat is niet altijd gemakkelijk: wanneer zijn kleine reparaties aan een huurhuis “structureel van aard” (dus voor rekening van de huisbaas)? Wanneer zijn GDPR-maatregelen “voldoende”? Is een uitgave wel of niet een “aftrekbare beroepskost”? En wie zijn nu exact die vage “bevoegde instanties” waar de wettekst naar verwijst? Allemaal voer voor discussie.

Via omzendbrieven of rulings wordt de gewenste interpretatie soms wel verder verduidelijkt van overheidswege, maar dan nog kom je zelden tot een volledige en sluitende verzameling regels. Is er onduidelijkheid, dan kan een miniem verschil in interpretatie een zaak maken of kraken. Beelden we ons een volautomatische omzetting van wettekst naar software in, dan riskeren we deze interpretatieve stappen over te slaan of zonder veel finesse te laten invullen door voorgeprogrammeerde default-waarden. Elke jurist zal huiveren bij dat idee, en terecht.

Rules as Code is dus niet zaligmakend en vindt vooral toepassingen waar regels ondubbelzinnig zijn en weinig interpretatie behoeven, of wanneer vaagheden aanvaardbaar zijn en behouden kunnen blijven in het eindresultaat. Het klassieke voorbeeld is een set regels die te herleiden zijn tot een beslisboom op basis van objectief berekenbare criteria. Applicaties die daarmee gepaard gaan zijn bijvoorbeeld aanvraagformulieren, simulatoren of rekenmodules. Regelgeving die eerder normatief van aard is, zoals EU-verordeningen met hun veelvuldig gebruik van vage termen zoals “voldoende”, “adequaat”, “geschikt”, “relevant”, … leent zich er niet toe – wat enkele academici gevat verwoord hebben als: “rechtvaardigheid kan men niet automatiseren”.

Hindernissen

Eens men begint aan de oefening om regelgeving om te zetten in code, botst men al snel op de complexe interne verwevenheden tussen allerlei wetten en besluiten. Een mooie illustratie is de Nederlandse pensioenleeftijd: zelf vrij rechttoe rechtaan gedefinieerd in artikel 7a van de betreffende wet, heeft ze impact op, of wordt ernaar verwezen in, minstens 100 andere Nederlandse wetten of statuten. Als daaraan gemorreld wordt, riskeer je dus al snel grote domino-effecten.

Daarnaast komt de wetgever creatief uit de hoek als er oplossingen gevonden moeten worden voor bepaalde zeldzame situaties. Het herbekijken of uitbreiden van definities, of toevoegen van uitzonderingsbepalingen of extra voorwaarden, is courante praktijk. Elk amendement kan op zijn beurt verwijzen naar weer andere regels of wetten, wat een hele keten aan afhankelijkheden met zich meebrengt.

Neem het concept van meerderjarigheid. In theorie is dat een eenvoudige regel: wie 18 is of ouder, is meerderjarig en bijgevolg handelingsbekwaam (art. 488 oud B.W.). Dat piepkleine artikeltje wordt echter gevolgd door een resem veel langere artikels over de uitzonderingen daarop (art.488/1 e.v.), tot en met bewindvoering (art. 494–502). Als dat niet voldoet, kan ook de vrederechter ingrijpen (art.492) en oordelen over een waslijst aan bekwaamheden die op moment van schrijven al 42 afzonderlijke items bevat (art.492/1 §2 + §3).

Stel dat een overheidsdienst subsidies mag uitdelen op basis van een reglement dat meerderjarigheid als voorwaarde stelt, en we willen een website bouwen waar burgers een eligibility check kunnen doen, dan is if (x≥18) programmeren niet altijd voldoende. Iemand die onder bewindvoering staat en zijn eigen geldzaken niet mag beheren, moet mogelijk alsnog een ander antwoord krijgen. Dat staat niet noodzakelijk expliciet in dat subsidiereglement, maar is een gevolg van het hanteren van de definitie van meerderjarigheid uit het burgerlijk wetboek.

Daarmee is de kous nog niet af: wetten kunnen eerdere definities uitbreiden of wijzigen. Zo wordt het concept van meerderjarigheid in de wet op de Maatschappelijke Integratie verruimd: minderjarigen die gehuwd zijn, zwanger zijn, of kinderen ten laste hebben worden gelijkgesteld aan meerderjarig (Art. 7) – maar enkel voor de toepassing van die wet. Samengevat: elke meerderjarige is 18+, maar niet elke 18+er is ten volle zelfstandig meerderjarig, en wat begrepen mag worden onder meerderjarigheid kan bovendien per toepassingsgebied nog verschillen.

Het temporele aspect voegt daar nog een hele dimensie van complexiteit aan toe. Niet al deze regels golden immers altijd. De meerderjarigheid op 18 jaar is in België pas in werking getreden op 1 mei 1990 (wet van 19 januari 1990, gepubliceerd in het Belgisch staatsblad op 30 januari 1990). Voordien moest men 21 zijn. De hierboven aangehaalde algemene bewindvoering werd dan weer voorafgegaan door verschillende speciale statuten, waaronder “verlengde minderjarigheid” en “voorlopige bewindvoering”. Deze werden afgeschaft in 2014, maar door een overgangsbepaling doofden ze pas uit in de praktijk op 1 september 2019. Wijzigingen gebeuren ook door gemeentelijke fusies, staatshervormingen, landen die niet meer bestaan, tijdelijke regels zoals de COVID-steunmaatregelen, …

Al is oude wetgeving al jaren opgeheven, de effecten ervan kunnen nog lang nazinderen. Zo zien we op onze belastingaangifte in 2025 nog een aftrekpost voor “bijzondere bijdragen voor de sociale zekerheid van de jaren 1982 tot 1988” (vak VIII, code 1388-67). Ook sociale rechten opgebouwd in statuten of regimes die vandaag niet meer bestaan, tellen nog steeds mee. Als een berekening afhangt van een situatie uit het verleden en de destijds geldende wetgeving, kan het dus nodig zijn om in een applicatie naast de huidige regelgeving ook de hele voorgeschiedenis ervan te implementeren.

Met al deze complexiteit in zelfs eenvoudige concepten, kan het niet anders of er duiken onvolledigheden of inconsistenties op. De Raad van State heeft haar handen vol met het adviseren van de wetgever, en haalt regelmatig fouten uit ontwerpteksten. Zelfs dan moet het Staatsblad vaak nog errata publiceren. Soms wordt de invulling van inhoudelijke details overgelaten aan de regering, maar laten de Koninklijke of ministeriële besluiten lang op zich wachten, waardoor er een tijd lang een vacuüm ontstaat. Andere keren is men niet exact genoeg in de verwoording: men verduidelijkt bijvoorbeeld niet of men spreekt over kalenderdagen of werkdagen.

Daar waar onvolledigheid, ogenschijnlijke tegenspraak of interpretatie voor discussie zorgt, moet het Hof van Cassatie soms één en ander ophelderen. Al is dat geen garantie op minder spraakverwarring in de toekomst, getuige dit recente arrest waarin ze aanstippen dat een motorvoertuig in de Wegverkeerswet, niet begrepen mag worden als een motorvoertuig zoals gedefinieerd in de Wegcode…

Tot slot zijn er nog gevallen waar de wettekst zelf grammaticaal ambigu is. Zo wordt in het uitvoeringsbesluit van de Brusselse Hoofdstedelijke Regering over werken die vrijgesteld zijn van stedenbouwkundige vergunning, vermeld in art. 21/1, 3° lid: “[…] de plaatsing van isolatie […] op een mandelige muur of een gevel die niet zichtbaar is vanaf de openbare ruimte […]”. Het is hier onduidelijk of de bijzin (aangevat met die) enkel betrekking heeft op de gevel, of zowel op de gevel als op de gedeelde muur. Ongetwijfeld tot ergernis van homegrade.brussels, dat particulieren hierover moet adviseren, en in haar informatiefiche over het onderwerp moet toegeven: “Dit artikel is voor verschillende interpretaties vatbaar”.

Dit alles is bij klassieke applicatie-ontwikkeling al een hele kluif. Wordt het dan eenvoudiger als we onze app bouwen rond een Rules as Code-framework? Niet echt: een RaC-framework reikt misschien een vaste methodiek of werkwijze aan, maar dat neemt de complexiteit niet weg: dezelfde karrevracht informatie moet er nog steeds ingeprogrammeerd worden, en ambiguïteiten blijven voor dezelfde problemen zorgen. Sommige RaC-engines zullen toelaten om lacunes in de regels te detecteren, maar dan nog moet je beslissen wat je ermee doet. Het project goed afbakenen en grenzen stellen is nog steeds noodzakelijk, om te vermijden overdonderd te worden door een lawine van afhankelijkheden, verwijzingen, en wijzigingshistoriek.

De basis: wetsanalyse

Stel dat we een app willen maken die een bepaalde wetgeving implementeert, en bijvoorbeeld berekent of je recht hebt op een specifieke subsidie en zo ja, hoeveel.

Allereerst is dan een manier nodig om die wet om te zetten in een gestructureerde vorm die de omzetting naar code faciliteert. Via een wetsanalyse trachten we elke regel uit die wet te ontleden in haar onderdelen. Het analyseschema hieronder, afkomstig van het Nederlands ministerie van Binnenlandse Zaken, is generiek toepasbaar en voorziet een opdeling in 15 klassen:

De variabelen zijn eigenschappen die voor elk rechtssubject (persoon of entiteit) kunnen verschillen: voor een persoon zijn dat bijvoorbeeld het geslacht, de woonplaats, de naam, de burgerlijke staat. De parameters daarentegen zijn de eigenschappen van de regel die gelijk zijn voor iedereen: een toepassingsgebied, een startdatum, een indexwaarde, … Zo zal een omzendbrief vaak tot doel hebben om parameters zoals de indexwaarde aan te passen, en zal een wet definiëren welke variabelen onder welke voorwaarden bij de toepassing van een regel in rekening gebracht mogen worden. Het is soms moeilijk te beoordelen of een term nu onder de variabelen of de parameters valt. De makers van deze methode geven bij elke klasse een omschrijving en voorbeelden die verduidelijken hoe ze uitgedrukt kunnen worden in een wettekst.

Nemen we als voorbeeld het recht op het moederschapsverlof, geregeld in hoofdstuk IV, art. 39 e.v. van de Arbeidswet. De basisregel daarvan is, bondig samengevat, dat een zwangere vrouw recht heeft op dit verlof vanaf 6 weken vóór de door de arts geschatte datum van de bevalling (8 weken bij meerlingen), plus 9 weken na de bevalling. Een rudimentaire analyse van deze regel volgens bovenstaand schema kunnen we als volgt aanvangen:

• De vrouw, haar werkgever en haar arts zijn allen rechtssubjecten, met elkaar verbonden door een arbeidsrelatie resp. arts-patiëntrelatie die rechtsbetrekkingen zijn.
• Een van de voorwaarden in deze wet is dat de bevallingsdatum is ingeschat door een arts in een geneeskundig attest dat aan de werkgever wordt overgemaakt. Dat attest is hier een rechtsobject.
• De variabelen van toepassing op de vrouw zijn onder andere: hoeveel kinderen ze verwacht, haar woonplaats, arbeidsplaats, bevallingsdatum… dit is voor elke vrouw anders.
• Parameters van deze wet zijn o.a. de minimum- en maximumtermijnen waarvan sprake: 6 weken, 8 weken, 9 weken, … die zijn gelijk voor elke vrouw.
• Tijds– en plaatsaanduiding zeggen waar en wanneer de regel geldt: op Belgisch grondgebied, en sinds de laatste wetswijzigingen vanaf 1 juli 2004 voor het prenatale en 1 maart 2009 voor het postnatale deel van het moederschapsverlof. De voorgeschiedenis van parameters kan ook worden vastgelegd. Variabelen kunnen ook tijdsaanduidingen hebben als ze evolueren doorheen de tijd.

De eigenlijke regelgeving voorziet o.a. nog in uitzonderingssituaties voor kinderen die te vroeg, ziek, of levenloos geboren worden,… Dat meenemen in de analyse kan leiden tot de toevoeging van vele extra parameters en variabelen om al deze uitzonderingen te vatten.

De afleidingsregel neemt dan de vorm aan van een berekening, waarbij:

• de input bestaat uit een “situatie” die beschreven wordt als een verzameling variabelen,
• de voorwaarden toelaten om bepaalde componenten van de berekening te activeren of niet,
• de parameters aan componenten van de berekening een gewicht geven,
• de output zowel een categorische als numerieke waarde kan zijn,
• de berekening kan steunen op andere afleidingsregels met hun eigen parameters, voorwaarden en variabelen.

Het staat ons vrij om te kiezen hoe granulair we daarin willen zijn, of hoe diep we willen gaan in onze analyse. We kunnen pietje precies zijn en elk detail van de regelgeving proberen encoderen, maar even goed kunnen we vrede nemen met het maken van enkele veralgemeningen, al was het maar om te vermijden dat de uiteindelijke app meer knopjes heeft dan een vliegtuigcockpit. Zo namen we hierboven de vrouw als startpunt, maar eigenlijk spreekt de wet van werkneemster. Dat impliceert een geldig arbeidscontract. Dat kunnen we integreren met extra variabelen en voorwaarden, en zelfs met extra regels over arbeidscontracten, maar biedt dat ook meerwaarde? Het kan voldoende zijn om het zo te laten en in een disclaimer te zeggen dat de app enkel van toepassing is voor werkneemsters.

Wetgeving correct in code vertalen is dus niet eenvoudig, en vergt de nodige afwegingen. Het is daarbij nuttig om een nauwe samenwerking op te zetten tussen juristen, die de regels helder kunnen uitleggen, en de software-ontwikkelaars die dat in code moeten gieten, met of zonder RaC-framework. Daaruit komen ook nieuwe profielen voort met zowel juridische als technische vaardigheden: we zien stilaan “legal engineers” en “beleidsprogrammeurs” opduiken. 

de Rules as Code aanpak

Het opzet van een Rules as Code benadering is om wetten, regels, policies, … te hertalen in een gestructureerd formaat dat door een machine begrepen kan worden. Dit kan dan op zijn beurt direct geïntegreerd worden in applicaties of websites. Het idee is dat deze applicaties zo gemakkelijker kunnen aangepast worden aan snel evoluerende regelgeving, en dat ook gebruikers ervan door de directe link met de wetgeving op meer transparantie kunnen rekenen.

Er bestaan geen internationaal aanvaarde standaarden voor wetsanalyse, noch voor encodering van wettekst. Het Nederlandse voorbeeld hierboven is generiek toepasbaar, maar is nog een jong initiatief. Bestaande Rules as Code engines hanteren andere conventies, die sterk van elkaar kunnen verschillen. Ze definiëren meestal hun eigen encodering, in de vorm van een Domain-Specific Language of Controlled Natural Language, waarin de regelgeving eerst omgezet moet worden. Pas als die stap is gebeurd, kunnen er verder applicaties op worden gebouwd.

Het gebrek aan gestandaardiseerde formaten, modellen en ontologieën bemoeilijkt de adoptie van Rules as Code. Tussen de verschillende proof-of-concepts in verschillende landen, soms ook binnen hetzelfde land, is de interoperabiliteit nog steeds vrij laag. Ieder land of ieder departement dreigt zo een eigen taal, aanpak of methodiek te gaan hanteren, wat leidt tot fragmentatie en dubbel werk. Idealiter zou gestreefd moeten worden naar een gestandaardiseerd vocabularium, en regels gepubliceerd in een uniform formaat, zodat ze hergebruikt en uitgewisseld kunnen worden tussen verschillende systemen en overheidsdiensten.

Onder de bestaande Rules as Code tools van enige grootte vinden we OpenFisca, PubliCodes, Català en RegelSpraak. We houden met opzet wat afstand van BPMN, CMMN, logische programmeertalen en klassieke rule engines, die niet toegespitst zijn op juridische teksten. In een volgend artikel verdiepen we onze analyse met een focus op tools die wel specifiek gebouwd zijn voor wetgeving, waarbij we er eentje zullen kiezen om technisch in detail te bekijken.

Tussentijdse conclusie

Rules as Code frameworks voorzien in een uniforme, generieke manier om aan wetsanalyse te doen. Voor programmeurs bieden ze een library met fundamentele bouwblokken om regelgeving te implementeren en testscenario’s op te zetten, ongeacht het domein waarin men actief is. Door de regelgeving te analyseren en om te zetten naar een domain-specific language, kan die door een rule engine of interpreter verwerkt worden. Belangrijk te noteren is dat deze omzetting vooralsnog minutieus analytisch mensenwerk vergt, omdat er interpretatie bij komt kijken. (Deze stap uitbesteden aan Large Language Models leidt niet tot onverdeeld positieve resultaten, maar daarover meer in een volgend artikel).

De mate van detail in veel regelgeving, maakt een analyse en omzetting naar een Rules as Code-formaat zelden een sinecure. Wil men tot een compleet en sluitend systeem komen dat rekening houdt met vele afhankelijkheden en uitzonderingssituaties, dan wordt men geconfronteerd met overdonderende hoeveelheden parameters en variabelen. Als berekeningen retroactief moeten kunnen zijn en ook de voorgeschiedenis van de wetgeving een rol speelt, komt daar nog een extra dimensie bij. De interne verwevenheden tussen alle regels maken dat men, om een Rules as Code-app van de grond te krijgen, al snel aankijkt tegen een grote initiële inspanning.

Eén van de argumenten voor Rules as Code is dat men bepaalde soorten apps generiek zou kunnen ontwikkelen voor eender welk domein: eligibility checkers, compliance tools, tax/benefit calculators, webformulieren, rekensimulatoren, dossierbeheer,… Zolang de onderliggende wetgeving maar duidelijk en concreet genoeg is, zou dan eenzelfde template-app zonder veel aanpassingen over de grenzen van overheidsdepartementen heen benut kunnen worden. Dit lovenswaardige idee stuit in de praktijk echter op moeilijkheden door de wetgeving zelf, die zichzelf haast heruitvindt in elk domein: zo kan je moeilijk gedeelde componenten ontwikkelen voor meerderjarigheid of motorvoertuigen als die termen verschillende definities hebben in verschillende wetten.

Een andere belofte van Rules as Code is dat apps ontwikkeld op basis van zulke frameworks een nauwe koppeling behouden met de wetgeving, die ook zichtbaar gemaakt kan worden. Deze koppeling moet transparantere garanties bieden dat een app wel degelijk conformeert aan de wetgeving, en dat dat ook zo blijft als die wetgeving morgen wijzigt. Daarnaast is er potentieel om te helpen bij het opstellen van regels. Een iteratief proces waarbij een RaC-versie van de regels wordt ontwikkeld in parallel met de ontwerpversie van de tekst, kan het mogelijk maken om vroegtijdig lacunes op te sporen en te verhelpen, of kan zelfs ex ante beleidsanalyse faciliteren door de impact van hypothetische wetswijzigingen eerst te simuleren (zie daarvoor ook het OESO-rapport). Maar ook hier komt men er niet onderuit dat de uitwerking daarvan, ook mét RaC-framework, dezelfde grote investeringen vergt.

Wie vreest dat computers het rechtssysteem binnenkort gaan overnemen kunnen we dus geruststellen, daar zijn we nog heel ver van weg. We herinneren ook nog even aan de GDPR, die in art.22 duidelijke grenzen stelt aan automatische besluitvorming. Daarnaast heeft een gecodeerde versie van een wet vooralsnog geen juridische status of rechtsgeldigheid – alleen de oorspronkelijke geschreven wettekst is bindend. Met andere woorden, zelfs al zetten we regelgeving om in code, is behoud van menselijk overzicht nog steeds een must, en heeft het Staatsblad nog steeds het laatste woord.

Wordt vervolgd!

Men zou bijvoorbeeld inzichten kunnen afleiden uit gegevens van overheden. Het is nuttig om dit proces uit te voeren op een computer want we zouden liever niet manueel grote hoeveelheden gegevens lezen om de interessante patronen en verbanden af te leiden. Bovendien valt een inzicht misschien pas op als de gegevens worden gelezen in de goede volgorde, bijvoorbeeld door een aantal stukjes informatie te lezen vlak na elkaar die allemaal eenzelfde interessante patroon bevatten. Men weet typisch niet op voorhand welke patronen aanwezig zijn, dus kan men de gegevens niet sorteren om de patronen er manueel uit te halen. Het vinden van patronen laten we daarom best door een computer gebeuren, die vele mogelijkheden kan overwegen.

In deze blog bespreken we een algemeen idee gebaseerd op principes uit Data Mining. We bespreken concreet het principe van regels. Een regel van de vorm A → B drukt de voorspelling uit dat patroon B voorkomt als patroon A wordt waargenomen. We lezen de regel dus als volgt: “als A dan B”. Dergelijke voorspellingen kunnen gebruikt worden om suggesties te doen, om anomalieën te detecteren, en om automatisch beslissingen te nemen.

We vertrekken vanuit de observatie dat veel gegevens van een overheid in gestructureerde vorm worden opgeslagen. Voorbeelden van dergelijke gegevens zijn:

• de data waarop de identiteitskaart van een persoon is uitgegeven,
• de voorgaande en huidige domicilieadressen van elke burger,
• de hoeveelheid belasting die elke burger heeft betaald per jaar,
• de bijdragen aan de sociale zekerheid die elke werkgever heeft betaald per kwartaal.

Gestructureerde gegevens staan in contrast met vrije tekst, afbeeldingen, video’s, geluid, enz.

Patronen en regels

In het vervolg nemen we voor de eenvoud aan dat elke gestructureerde gegevensbron conceptueel bestaat uit een verzameling van entiteiten, zoals mensen, gebouwen, bedrijven, enz. We bekijken elke entiteit als een verzameling van attributen, waarbij elk attribuut een key-value paar is.

We definiëren een patroon als een combinatie van constraints op individuele attributen. De “support” van een patroon X is het aantal voorkomens (of de relatieve frequentie) van X over alle entiteiten heen. Ter illustratie beschouwen we de volgende tabel:

Elke rij stelt een entiteit voor, in dit geval een persoon. Voorbeelden van patronen zijn:

• Straat = “Straat A”;
• Leeftijd > 35;
• Leeftijd > 35 en Gebied_code = 3000.

De support van deze patronen zijn, respectievelijk: 1 rij, 3 rijen, en 2 rijen.

Als we vanuit de gestructureerde gegevens zouden kunnen leren welke patronen vaak samengaan, kunnen we het ene patroon voorspellen na de observatie van een ander patroon. In het bijzonder zouden we regels kunnen leren van de vorm A → B, waar A en B patronen zijn. Deze regel zegt dat als we patroon A zien dat we dan patroon B verwachten. Bij elke regel hoort een betrouwbaarheidsscore, gedefinieerd als volgt:

De betrouwbaarheid van A → B is de support van het gecombineerde patroon A + B gedeeld door de support van patroon A.

Merk op dat het gecombineerde patroon A + B typisch strenger is dan patroon A, en daardoor enkel kan aanwezig zijn in de entiteiten die reeds voldoen aan patroon A. Daardoor is de support van A + B kleiner of gelijk aan de support van A. Intuïtief bekeken, drukt de betrouwbaarheid uit hoe zeker we zijn om patroon B te voorspellen als we patroon A waarnemen.

In het bovenstaande voorbeeld, zouden we de volgende regels kunnen afleiden uit de gegevens:

• Met 2/2 betrouwbaarheid (100%), als Straat= “Straat B” en Gebied_code = 3000 dan (→) Taal = “Frans”;
• Met 2/3 betrouwbaarheid (66%), als Gebied_code = 3000 dan (→) Taal = “Frans”.

Met regels zouden we de volgende toepassingen kunnen uitwerken:

• Men kan waarden voor een attribuut suggereren op basis van andere attributen. Dit zou men decision support kunnen noemen.
• Wanneer een entiteit wordt aangemaakt (of gewijzigd), kan men controleren dat bepaalde verwachtingen rond de attributen voldaan zijn. Anders gezegd: men kan verwachtingen gebruiken als beperkingen. Schendingen van verwachtingen kunnen gemeld worden als anomalieën.

Beide mechanismen zijn gebaseerd op voorspellingen, zoals we hieronder zullen toelichten. Met kennis van de regel A → B kunnen we suggereren dat patroon B kan toegepast worden nadat patroon A wordt waargenomen. Als een beheerder verantwoordelijk blijft voor de uiteindelijke beslissing, dan bekijken we regels enkel als een suggestie-mechanisme. In de context van anomalie-detectie kunnen we een melding sturen naar de beheerder wanneer een voorspelling wordt geschonden bij een entiteit. Ter illustratie:

• Stel dat de bovenstaande voorbeeld-gegevens van personen uit een enquête zouden komen, en dat mensen soms vergeten hun taal in te vullen. In dat geval zouden we kunnen overwegen om een suggestie-mechanisme aan te bieden dat de taal afleidt uit de straat en de gebiedscode. Natuurlijk hangt het af van de toepassing of de voorgestelde waarden aanvaardbare plaatsvervangers zijn, of dat meer echte gegevens moeten verzameld worden.
• Als een voorbeeld van anomalie-detectie, stel dat we proberen om de volgende entiteit toe te voegen aan de tabel: Staat= “Straat B”, Gebied_code = “3000”, en Taal = “Nederlands”. De eerste regel hierboven zou dan geschonden zijn. Als de betrouwbaarheid van een geschonden regel hoog is, zoals hier (100%), dan zou het nuttig kunnen zijn om de anomalie te melden aan een beheerder. Afhankelijk van de toepassing, zou anomalie-detectie kunnen helpen bij het vinden van administratieve fouten of problemen met entiteiten.

Als een regel voldoende wordt vertrouwd, en de patronen erin voldoende concreet zijn, dan kan de regel ook automatisch worden uitgevoerd om gegevens aan te vullen of te veranderen. Daarom zouden regels een manier kunnen zijn om automatisering te bekomen.

Toepasbaarheid

Men zou regels kunnen leren uit verschillende vormen van gestructureerde gegevens zoals:

1. Standaard tabellen zoals in het bovenstaande voorbeeld.
2. XML of JSON gegevens wanneer de diepte van deze structureren op voorhand begrensd is.
3. Doorlopende “streams” waar gestructureerde formaten worden gebruikt om individuele boodschappen voor te stellen. Het leren van regels over streams kan real-time aanvulling van gegevens of anomalie-detectie mogelijk maken.

Nuttige eigenschappen

We bespreken enkele nuttige eigenschappen van het automatisch afleiden van regels:

Aanvullende opmerkingen

Verwante onderzoeksgebieden

We geven enkele wetenschappelijke onderzoeksgebieden verwant aan het thema in deze blog (Engelstalige terminologie):

• association rule mining,
• inductive logic programming,
• knowledge representation and reasoning.

Slim gokken

In het algemeen zijn er teveel mogelijke patronen en regels om systematisch op te sommen of op te slaan. Maar men kan patronen en regels proberen slim te gokken. Het is in principe ook mogelijk om variaties van bestaande regels te verkennen, ten einde

• meer algemene regels te vinden;
• of om regels met lage betrouwbaarheid om te vormen naar regels met hogere betrouwbaarheid, bijvoorbeeld door een meer specifiek patroon te gebruiken in de preconditie.

Trade-off: betrouwbaarheid en support

Er zit een trade-off tussen betrouwbaarheid en support. Regels gebaseerd op gedetailleerde patronen zouden heel betrouwbaar kunnen zijn, maar helaas met een te kleine support om statistisch significant te zijn. Een kleine support duidt immers op zeldzaamheid van het patroon. Daarom zou men aandacht kunnen besteden aan representaties van patronen die zorgen voor een grotere support. Hulpmiddelen daarvoor zijn:

• beperkingen op getal-attributen kan men weergeven met intervallen (en niet met concrete waarden);
• gebruik maken van de NOT operator (“niet”), om te zeggen dat een attribuut niet een bepaalde waarde heeft;
• gebruik maken van de OR-operator om meerdere specifieke patronen te bundelen.

Bijvoorbeeld, door te zeggen NOT Straat = “Straat Z”, laten we toe dat het straat-attribuut zeer veel waarden kan aannemen, zolang het maar niet “Straat Z” is, zoals: “Straat A”, “Straat B”, “Straat C”, en tal van andere mogelijke waarden. De support van het patroon NOT Straat = “Straat Z” kan daarom heel hoog zijn in een concrete tabel.

We geven nu een voorbeeld van het gebruik van de OR-operator. Beschouw het volgende patroon, waarbij we voor de leesbaarheid telkens een komma schrijven om “and” voor te stellen:

P= (a OR b), (u OR v), (x OR y).

Patroon P vervangt de volgende verzameling van specifieke patronen waarin enkel de  AND-operator wordt gebruikt (ook weer vervangen door komma):

• a, u, x
• a, u, y
• a, v, x,
• a, v, y,
• b, u, x,
• b, u, y
• b, v, x,
• b, v, y.

De support van P kan veel hoger zijn dan de support van de individuele AND-patronen. Dit voorbeeld illustreert bovendien dat een representatie met een geneste OR-operator efficiënter kan zijn voor de opslag van de patronen en regels.