Heart for people
Mind for tech

Eén woord, drie betekenissen: wat bedoelen we met een ontologie?

Ontologieën zijn terug, dankzij AI-agents. Wat Palantir, Microsoft Fabric en een Berkeley-docent ermee bedoelen, en wat je er als Product Owner morgen mee kunt.

Chris Lukassen

—

AI Inzichten

Een man met bril kijkt over een opengeslagen Koenen-woordenboek Nederlands.

Written by

Chris Lukassen
Head of Product

Wie de afgelopen maanden naar praatjes over AI heeft gekeken, kwam het woord steeds vaker tegen: ontologie. Palantir bouwt er zijn hele platform omheen. Microsoft heeft er een eigen onderdeel voor in Fabric. En op conferenties over AI-agents is het inmiddels een vast onderwerp.

Het probleem eronder is oud. Een klant, een order of een machine bestaat in vijf systemen, elk met eigen namen, velden en koppelingen. Wie een eenvoudige vraag stelt, moet eerst weten welke tabellen hij moet combineren en welke bron leidend is. Die kennis zit in hoofden en in losse scripts.

Het concept is niet nieuw. Domeinmodellen, een gedeelde taal tussen business en techniek en formele kennismodellen bestaan al decennia. Nieuw is dat het nu overal ontologie heet en dat het ineens over AI-agents gaat. Drie recente video's laten mooi zien hoe verschillend het woord daarbij wordt gebruikt: een talk van een Berkeley-docent, een uitleg van Palantir en een interview over Microsoft Fabric. Ze gebruiken hetzelfde woord voor drie verschillende dingen. En voor Product Owners zit de les niet in de techniek, maar in de vraag welke beslissingen je vastlegt.

De bouwstenen

De klassieke definitie komt van Tom Gruber uit 1993: een ontologie is een formele specificatie van een gedeelde conceptualisering. Palantir zegt het eenvoudiger: de zelfstandige naamwoorden en werkwoorden van je bedrijf.

De zelfstandige naamwoorden beschrijven wat er bestaat:

  • Object types zijn de echte dingen, zoals Klant, Order of Levering.
  • Properties zijn hun eigenschappen, zoals een leverdatum of een orderbedrag.
  • Link types zijn de relaties: een Order hoort bij een Klant en heeft een Levering.

De werkwoorden beschrijven wat je mag doen:

  • Actions zijn vastgelegde manieren om iets te veranderen, inclusief wie dat mag en waar het resultaat naartoe gaat.
  • Functions zijn de rekenregels en modellen die bij een object horen, zodat iedereen dezelfde berekening gebruikt.
  • Rechten gelden per object en per eigenschap, en reizen mee met de data.

Palantir geeft er een ontwerpregel bij die ik graag onthoud: modelleer hoe je bedrijf werkelijk werkt, niet hoe je systemen het nodig hebben.

Drie betekenissen van hetzelfde woord

De drie video's bedoelen elk iets anders met een ontologie. Het verschil zit vooral in de vraag of je er ook mee kunt handelen.

  • Frank Coyle (Berkeley) gebruikt de oudste betekenis, uit de informatica: een formeel kennismodel met logische regels (RDFS, OWL) dat naast de data staat. Het handelt niet zelf, maar keurt goed of af wat een agent voorstelt.
  • Palantir ziet het als een digitale tweeling van het bedrijf: data, logica en acties. Het kan handelen, bijvoorbeeld door vanuit het model een voorraadverplaatsing in SAP aan te maken. Zo hoeft niemand meer van een dashboard naar een ander systeem te schakelen.
  • Microsoft Fabric zet de ontologie als contextlaag voor agents bovenop het bestaande semantische model, bereikbaar via Fabric IQ en MCP. In de demo leest de agent alleen en geeft hij antwoord. De spreker noemt het product zelf nog in ontwikkeling.

Waarom het nu speelt

Ontologieën bestaan al decennia. Dat ze nu terug zijn, komt door AI-agents. Coyle legt het helder uit: een taalmodel kan zelf niets uitvoeren. Het stelt een tool-aanroep voor, en jouw code voert die uit. Precies op dat moment kun je controleren.

Zijn slogan is "Pydantic at the door, ontology at the ledger". Eerst controleer je of de parameters het juiste type hebben. Daarna controleer je of de uitkomst in jouw domein logisch kan. Hij noemt drie fouten die in gewone taal lastig af te vangen zijn, maar in een ontologie eenvoudig:

  • een tweede terugbetaling op dezelfde order;
  • een uitbetaling aan de supportmedewerker in plaats van aan de koper;
  • een verzonnen status als "probably shipped".

Palantir en Microsoft zeggen in andere woorden hetzelfde. Een taalmodel is niet getraind op jouw bedrijf. De ontologie geeft het die context en begrenst wat het mag doen.

Hier zit voor mij de les die verder gaat dan techniek. Een ontologie is geen dataproject. Het is een productbeslissing: welke beslissingen wil je vastleggen, wie mag ze nemen, en wat mag een agent namens jou doen? Wie daar geen antwoord op heeft, bouwt een mooi model dat niemand gebruikt. Ik heb dat patroon zelf vaker gezien dan me lief is, bij datacatalogi en semantische lagen.

Wat moet je er als Product Owner mee?

Het goede nieuws: je doet het al half. De zelfstandige naamwoorden van een ontologie staan in je Product Backlog. De werkwoorden staan in je product backlog items. Een item als "Klantenservice keurt een terugbetaling goed" beschrijft een object, een actie en een rol. Wat ontbreekt, is dat het expliciet, gedeeld en eenduidig is vastgelegd.

Vijf dingen die je morgen kunt doen:

  1. Maak de taal van je product zichtbaar. Zet de vijf tot tien kernobjecten en hun relaties op één A4. Vraag drie teams wat een "klant" of een "order" is. Krijg je drie antwoorden, dan weet je waar je eerste probleem zit.
  2. Schrijf acties als beslissingen met regels. Wie mag het, onder welke voorwaarden, en wat gebeurt er daarna? Dat zijn je acceptatiecriteria vandaag, en straks de grenzen van een agent.
  3. Bepaal wat een agent mag. Deel je acties in drie bakjes: de agent doet het zelf, de agent stelt voor en een mens beslist, of alleen een mens. Dat is geen technische keuze maar een productkeuze, en dus de jouwe.
  4. Behandel het model als product. Het heeft een eigenaar, een backlog en versies nodig. Bronnen veranderen voortdurend; een model zonder eigenaar veroudert binnen een jaar.
  5. Stel de goede vragen bij een demo. Welke betekenis van ontologie bedoelt de leverancier? Kan het handelen of alleen lezen? Wie onderhoudt het model als jouw systemen veranderen?

Een klein voorbeeld laat zien hoe dicht dit bij je dagelijkse werk ligt. Neem het product backlog item "terugbetaling goedkeuren". De drie fouten van Coyle zijn gewoon acceptatiecriteria:

  • Per order kan maximaal één terugbetaling worden goedgekeurd. In de ontologie: een functionele property, er kan er maar één zijn.
  • Het geld gaat altijd naar de koper. In de ontologie: koper en medewerker zijn verschillende soorten objecten.
  • De status is altijd betaald, verzonden of terugbetaald. In de ontologie: een vaste lijst van toegestane waarden.

Het verschil: in een product backlog item staan die regels in een ticket dat na de Sprint verdwijnt. In een ontologie staan ze op één plek, en gelden ze voor elke app, elk dashboard en elke agent.

Als Product Owner werk je steeds vaker niet alleen voor developers, maar ook voor agents. Een ontologie kan je daarbij helpen. Een agent leest namelijk niet wat er niet in het ticket staat. Een developer vult de gaten aan uit gesprekken, ervaring en de koffieautomaat; een agent heeft alleen de context die je expliciet hebt vastgelegd. Daarover schreven we eerder in Bijna elke AI-fout begint in het ticket.

Welke actie in jouw product zou jij als eerste aan een agent toevertrouwen? En welke juist nooit?

Bronnen