OrgForge: A Multi-Agent Simulation Framework for Verifiable Synthetic Corporate Corpora

OrgForge is een open-source multi-agent simulatieframework dat deterministische gebeurtenislogboeken en een strikte scheiding tussen feitelijke basiswaarheid en door LLM's gegenereerde tekst gebruikt om verifieerbare, tijdschijn-consistente synthetische corpora van bedrijfscommunicatie te genereren voor het evalueren van RAG-pipelines.

De kern

Stel je voor dat je een nieuwe, slimme robot wilt trainen om het kantoorleven te begrijpen. Je wilt dat hij e-mails leest, Slack-berichten snapt en weet wie wat heeft gedaan. Maar hoe test je of die robot echt slim is?

Het probleem is dat echte kantoorbestanden vaak een rommeltje zijn: ze zijn onvolledig, soms juridisch gevoelig, en niemand weet precies wat er "echt" gebeurd is. Als je zelf een verhaal bedenkt met een AI, kan die AI tegenstrijdigheden creëren (bijvoorbeeld: "De server viel om 3 uur 's nachts uit" in één bericht, maar "De storing begon om 9 uur" in een ander). Dan is je test onbetrouwbaar.

OrgForge is de oplossing voor dit probleem. Het is een soort digitale fabriek die een volledig, nep-bedrijf simuleert, maar dan met een heel belangrijk trucje: de feiten en de verhalen worden gescheiden.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Regisseur en de Acteurs (Het "Fysiek vs. Verhaal" Systeem)

Stel je een toneelstuk voor.

• De Regisseur (De Motor): Dit is een simpele, onfeilbare computercode. Hij houdt een streng dagboek bij. Hij weet precies: "Om 10:00 viel de server uit", "Jan is de enige die dit kan oplossen", en "De spanning loopt op". Deze regisseur mag nooit liegen of hallucineren. Hij bepaalt de feiten.
• De Acteurs (De AI's): Dit zijn de grote taalmodellen (zoals ChatGPT). Hun enige taak is dialogen schrijven. Ze krijgen van de regisseur een opdracht: "Schrijf een Slack-bericht van Jan waarin hij paniek heeft omdat de server uitvalt." De AI mag het verhaal vertellen, maar mag niet beslissen of de server wel of niet uitviel. Als de regisseur zegt dat de server nog werkt, dan schrijft de AI geen bericht over een uitval.

Dit zorgt ervoor dat het eindresultaat (de e-mails, tickets, chats) er heel realistisch uitziet, maar dat de feiten eronder 100% kloppen. Je kunt er dus op vertrouwen.

2. Het Spel van de Spanning (Stress en Relaties)

OrgForge is niet statisch; het voelt als een echt bedrijf.

• Stress: Als er veel werk is, krijgen de "werknemers" (de digitale personages) stress. Als een sleutelpersoon (de "centrale hub" in het netwerk) overbelast raakt, verspreidt die stress zich naar zijn collega's, net als een golfbeweging.
• Relaties: Als twee mensen samenwerken aan een probleem, worden ze "vriendelijker" (hun relatie wordt sterker). Als ze elkaar lange tijd niet spreken, verflauwt de band. Dit wordt berekend met wiskundige formules, niet door de AI.

3. De Tijdreis die niet bestaat (Causale Kloksynchronisatie)

Een groot probleem bij nep-data is dat de tijd vaak door elkaar loopt. Een e-mail kan een datum hebben die na de reactie ligt.
OrgForge gebruikt een persoonlijke klok voor elke werknemer.

• Stel: Jan start een Slack-gesprek. De klok van Jan loopt vooruit. Als Marie reageert, kijkt haar klok eerst naar de tijd van Jan en loopt dan pas verder.
• Hierdoor is het onmogelijk dat een reactie voor de oorspronkelijke melding staat. De tijdlijn is altijd logisch en kloppend.

4. Het Netwerk van Gebeurtenissen (De "Causale Keten")

Wanneer er een probleem ontstaat (bijvoorbeeld een servercrash), start OrgForge een detective-verhaal.

• Het begint met een waarschuwing.
• Dan volgt een Slack-bericht.
• Dan een JIRA-ticket.
• Dan een e-mail naar een leverancier.
• Dan een post-mortem verslag.

OrgForge koppelt al deze losse stukjes aan elkaar als een ketting. Als je later vraagt: "Wat gebeurde er precies na de crash?", kan het systeem het hele verhaal terugsporen, van de eerste waarschuwing tot de oplossing. Zelfs e-mails van buiten het bedrijf (klachten, leveranciers) worden in deze keten opgenomen.

5. De Test (Hoe weten we of de robot slim is?)

Na de simulatie heeft OrgForge een examen voor je AI-robot.

• Het stelt vragen zoals: "Wie was de eerste die de klantklacht zag?" of "Waarom duurde dit ticket drie dagen langer dan gepland?"
• Omdat OrgForge het "dagboek" (de feiten) heeft, weet het precies wat het juiste antwoord is.
• Het kijkt niet alleen of het antwoord goed is, maar ook of de robot de juiste documenten (bewijs) heeft gevonden om tot dat antwoord te komen.

Waarom is dit belangrijk?

Vroeger moesten we AI testen met oude, rommelige e-mails van echte bedrijven (zoals het Enron-archief) of met volledig verzonnen verhalen die vaak tegenstrijdigheden bevatten.
OrgForge biedt een perfecte, schone testomgeving. Het is alsof je een auto test op een gesloten circuit waar je precies weet hoe de weg eruitziet, in plaats van hem door een stormachtige stad te sturen waar je niet weet of de verkeerslichten wel werken.

Kortom: OrgForge is een digitale toneelgroep die een perfect georganiseerd, nep-bedrijf neerzet, zodat we kunnen zien of onze slimme computers echt begrijpen hoe bedrijven werken, zonder dat we hoeven te twijfelen aan de feiten.

Technische samenvatting

Titel: OrgForge: Verifieerbare Synthetische Bedrijfskorpora

1. Het Probleem

De evaluatie van Retrieval-Augmented Generation (RAG) pipelines voor enterprise-toepassingen kampt met een gebrek aan geschikte testdata. Bestaande benchmarks hebben de volgende tekortkomingen:

• Realistische data (bijv. Enron-corpus): Bevat juridische ambiguïteiten, demografische vertekening en mist gestructureerde "ground truth" (een autoritair record van wat er daadwerkelijk gebeurde).
• Volledig door LLM gegenereerde data: Hoewel dit juridische problemen oplost, introduceert het een fundamenteel probleem: LLMs kunnen hallucineren. Een gegenereerd corpus kan intern inconsistent zijn (bijv. een Slack-bericht zegt dat een incident om 03:00 begon, terwijl een JIRA-ticket het op 09:00 plaatst). Zonder externe validatie is het onmogelijk om te detecteren of een RAG-systeem correct redeneert of toevallig een inconsistent antwoord geeft.

Er is behoefte aan corpora met traceerbare ground truth, temporele structuur, coherentie over verschillende artifacten (Slack, JIRA, e-mail, logs) en configureerbare complexiteit.

2. Methodologie: De OrgForge Architectuur

OrgForge is een open-source multi-agent simulatieframework dat een strikte scheiding maakt tussen feitelijke controle en prose-generatie. De kernarchitectuur wordt gedefinieerd als een tuple $M = (S, P, V, E)$:

• $S$ (State): Een deterministische Python-engine die de simulatiestatus beheert (systeemgezondheid, moreel, stressniveaus, open tickets).
• $P$ (Planners): LLM-agents die voorstellen doen voor activiteiten (narratieve richting), maar geen feiten kunnen wijzigen.
• $V$ (Validator): Een deterministische functie die alle LLM-voorstellen valideert tegen de huidige staat ($S$) en de gebeurtenisgeschiedenis ($E$). Alleen goedgekeurde voorstellen worden uitgevoerd.
• $E$ (Events): De "SimEvent" bus. Dit is het enige autoritaire logboek van feiten. Alle belangrijke acties genereren een gestructureerd SimEvent. LLMs genereren alleen de oppervlakte-tekst (prose) gebaseerd op deze context.

Belangrijke technische componenten:

• Grafische Dynamica: Drie deterministische mechanismen sturen het organisatiegedrag onafhankelijk van LLMs:
  1. Stresspropagatie: Gebaseerd op betweenness centrality; stress verspreidt zich van "burn-out" sleutelfiguren naar collega's.
  2. Temporele edge-weight decay: Relaties verzwakken zonder interactie en versterken bij samenwerking (PR's, incidenten).
  3. Dijkstra Escalatie: Incidenten worden gerouteerd via de sterkste communicatiebanden (kortste pad op een inverse-gewicht grafiek).
• Actor-Lokale Klok: In plaats van onafhankelijke timestamps te genereren, onderhoudt elke actor een eigen tijdscursor. Dit garandeert causale tijdstipcorrectheid (een reactie kan nooit eerder plaatsvinden dan de trigger).
• Causale Ketens & Recurrentie: Een subsystem bouwt geordende grafieken van artifacten per incident op. Een hybride Reciprocal Rank Fusion (RRF) detector identificeert terugkerende foutklassen door vector- en tekstzoekopdrachten te combineren.
• Externe E-mail Engine: Simuleert inkomende/uitgaande e-mails (leveranciers, klanten, HR) met probabilistische "drop"-simulaties om communicatiegaten te creëren voor evaluatie.
• Sociale Interrupties: Voegt "ruis" toe (bijv. koffiegesprekken) om realistische capaciteitsvariatie te modelleren, zodat RAG-systemen getest worden op het filteren van relevante informatie uit een ruisende stroom.

3. Belangrijkste Bijdragen

1. Architecturale Scheiding: Een bewezen methode om hallucinaties te voorkomen door feiten te scheiden van tekstgeneratie via een validator-lus.
2. Formele Specificaties: Drie wiskundig gedefinieerde mechanismen voor stress, relatie-dynamiek en escalatie.
3. Multi-Artifact Coherentie: Generatie van doorlopende verhalen over Slack, JIRA, Confluence, Git, e-mail en serverlogs, allemaal gekoppeld aan één SimEvent-log.
4. Evaluatie-Pipeline: Een compleet systeem (eval_harness.py, scorer.py) dat acht typen vragen genereert (o.a. retrieval, causaal, temporeel, gap-detectie) met deterministische ground truth en een scoringssysteem dat zowel antwoordkwaliteit als retrieval-kwaliteit meet.
5. Open Source Implementatie: Het framework is beschikbaar via GitHub en HuggingFace, met ondersteuning voor reproduceerbare generatie via seeds.

4. Resultaten

De auteurs voerden een simulatie uit van 22 werkdagen met een organisatie van 43 personen, resulterend in 1.079 documenten en 83 evaluatievragen.

• Kosten: De simulatie kostte ongeveer $285 (input/output tokens) en duurde ~3 uur.
• Retrieval Baselines:
  • BM25 (Keyword): Presteerde het beste op Causale vragen (MRR@10 = 0.54) en Gap Detection (0.50). Dit komt doordat specifieke terminologie in post-mortem documenten goed matcht met zoekopdrachten.
  • Dense Retrieval (Embeddings): Presteerde over het algemeen slechter dan BM25 (Overall MRR@10 = 0.20 vs 0.28), behalve bij Retrieval-vragen waar semantische overeenkomst iets beter werkte.
  • Zwakke Punten: Beide methoden scoorden 0 op Plan- en Escalatie-vragen. Dit bevestigt dat deze vragen complexere redenering vereisen (tema-context en multi-hop actor-chains) die puur retrieval niet kan oplossen.
• Observatie: De resultaten tonen aan dat bestaande retrieval-methoden onvoldoende zijn voor complexe enterprise-scenario's en dat er een duidelijke "performance floor" is voor toekomstige agente systemen.

5. Betekenis en Toekomstperspectief

OrgForge biedt een fundamentele doorbraak voor de RAG-evaluatie door verifieerbare ground truth te introduceren in synthetische data. Het lost het dilemma op tussen juridisch veilige data en data die intern consistent is.

• Impact: Het stelt onderzoekers in staat om RAG-systemen te testen op realistische, tijdsgebonden en cross-artifact scenario's zonder de risico's van hallucinaties in de testdata zelf.
• Toekomst: De auteurs plannen experimenten voor end-to-end RAG-agent evaluatie, cross-corpus contradictie-analyse (om te bewijzen dat OrgForge geen hallucinaties bevat) en uitbreiding naar multi-organisatie simulaties (leveranciers en klanten met eigen staten).

Kortom, OrgForge verschuift de evaluatie van RAG van statische, vaak onbetrouwbare datasets naar dynamische, causaal correcte en reproduceerbare simulaties die de complexiteit van echte enterprise-omgevingen nabootsen.