And why AI can’t put it back on its own
Imagine you are looking at a diagram in which David and Johan are connected by a line labelled “associated with”. What does it tell you? Perhaps David manages Johan. Perhaps they are colleagues, or old friends, or they once shared a taxi. The line is true, and at the same time almost useless: you can’t ask “who reports to David?” because the model doesn’t have the information you need.
This brief example highlights how semantics, i.e. meaning with a precise definition, is what separates a model you can reason with from a picture you can only look at. Simplifying semantics to make things easier is tempting, but the cost is that you lose the meaning that makes the model so valuable.
Simple is not the same as clear
Most modelling approaches start from a good instinct: keep the vocabulary small so people can learn it. A handful of boxes and a handful of arrows. The trouble is that the real world has far more kinds of relationship than the arrows can hold, so the same arrow ends up doing several jobs.
Suppose a model has one relationship, “contributes to”, and uses it for everything connected to Friday’s dinner:
- The chef contributes to the dinner (they cooked it).
- The recipe contributes to the dinner (it described how to make it).
- The receipt contributes to the dinner (it proves the ingredients were bought).
- The farmer contributes to the dinner (they grew the vegetables).
- Every line is true, and the diagram looks nice and tidy. Now ask a simple question: who made the dinner?
The model returns four answers: a chef, a recipe, a receipt and a farmer. You can probably guess that only the chef cooked it, but the model doesn’t tell you that. They are all “contributors”, and it doesn’t say how. What does AI see? Without any distinctions, AI has no reliable meaning to work from, and because the model doesn’t distinguish between supplying the ingredients and actually preparing the meal, it might suggest that either the farmer or the chef cooked dinner.
Things change if we give each relationship its own meaning:
- The chef cooked the dinner.
- The recipe describes the dinner.
- The receipt evidences the dinner’s ingredients.
- The farmer supplied the vegetables.
“Who made the dinner?” now has one answer, and “what proves we bought the ingredients?” has another. The facts are the same, but you can ask each question separately and get a clean result.
The tidy diagram is what makes the vagueness easy to miss. Nothing looks wrong until someone asks a question and the answer comes back ambiguous.
The same problem in an IT model
The same thing happens in a typical IT model. For example, a company handles customer orders, and every connection is drawn using general-purpose relationships such as “realises”, “serves”, “accesses” and “associated with”:
- Order Management System realises Order Service.
- Order Service serves Order Handling Process.
- Order Handling Process realises Order Fulfilment Capability.
- Order Handling Process accesses Customer Order Data.
- Order Management System is associated with Customer Order Database.
- Order Management System v2 realises the requirement “Confirm orders within 1 hour”.
- order-app.war (a software artefact) realises Order Management System.
- Order System Upgrade (a work package) realises Order Management System v2.
Every line is valid, and the diagram looks consistent. The problem appears when you ask, “If we retire the Order Management System, what is affected?”
Because the relationships are expressed in abstract terms, the answer mixes the Order Service, the build file and the Customer Order Database. All are connected, but their roles are fundamentally different. The model does not explicitly distinguish between a service the business relies on, a technical artefact used to deploy an application and a database whose orders may need migrating. Experienced modellers will point out that element types and the direction of each relationship carry some of this meaning, and they do. But that meaning then lives in rules every query has to encode, not in the relationships themselves, and it is lost as soon as an element is mistyped or the model leaves the tool that knows those rules.
Here is what each relationship is actually expressing. Some, such as “serves”, were already fairly precise; the gain comes from replacing the ones that were doing several jobs:
- Order Management System providesOrder Service
- Order Handling Process usesOrder Service
- Order Handling Process contributes toOrder Fulfilment Capability
- Order System Upgrade deliversOrder Management System v2
- order-app.war is a deployable artefact ofOrder Management System
- Order Management System stores its orders in Customer Order Database
- Order Handling Process updates Customer Order Data
- Order Management System v2 satisfiesthe requirement “confirm orders within 1 hour”
Now the retirement question has a clean answer: the Order Service is lost, the Order Handling Process that uses it is affected, and so is the Order Fulfilment Capability it contributes to. The build file goes with the system, and the orders in the Customer Order Database need migrating.
Using a small set of general-purpose relationships keeps the modelling language small and the diagrams easy to learn, which is a sensible trade-off for communication. However, the cost is precision when you want to ask questions of the model, understand dependencies or reason over the model.
Two more ways meaning slips away
The arrow that says “something moves”. Draw a line from Alice to Bob labelled “sends”. Is it a rent payment, a birthday card or a rumour? Is it monthly or once a year? Is it private? Without those answers you can’t ask the question that matters: “what confidential information leaves Alice’s house, and where does it go?” Say what is sent, how often and how private it is, and that question has an answer. Here the verb is clear but the detail is missing, which is a different failure from the overloaded word above.
The label that has no rules. Say you add “sports car” as a type of car. Nothing in the model separates it from any other car, so nobody can tell whether a given car qualifies. Compare “electric car”, which has a battery, a charging connector and no fuel tank. That type adds things you can check, so a so-called electric car with a fuel tank is caught immediately. A type that adds nothing is only a tag.
What good semantics look like
Good semantics aren’t more complicated for the sake of it. They answer four plain questions about every relationship:
- What does it mean, in one sentence?
- Which way does it point?
- How many of each can there be?
- What question does it let me ask?
“David manages Johan” passes. It means David is Johan’s line manager, it points from David to Johan, a person has at most one line manager, and it answers “who reports to David?” Compare “David is associated with Johan”, which passes none of them.
The third question, how many, matters more than it looks, and so does a related one: can one thing exist without the other? If you demolish a house, the bedrooms go with it, because a bedroom belongs to exactly one house. If a football club closes, the players don’t, because they can exist without the club and can join another. Those are different relationships with different consequences, and a model that treats them the same will get its totals and its clean-up wrong.
“Can’t AI just work this out?”
It’s a question we’ve been asked a few times, and AI is genuinely useful here. It can read a pile of data, spot that two columns look like a person and a manager, and suggest a draft structure in minutes. Done by hand, that can take weeks.
But AI can only work with the meaning that was captured, and data shows structure far better than it shows intent. A field called “owner” that links a person to a record could mean the accountable owner, the person who created it or the last one to edit it. The link is visible, but the meaning isn’t in the data at all. Ask an AI to name the relationship and it will give you a sensible-sounding label, perhaps “owns” today and “manages” tomorrow, and it will do so with confidence.
That creates a few specific problems:
It builds on your flaws. If your source system lumps products, installations and services into one overloaded table, the AI will likely build one confused concept, because that’s what the evidence says.
It drifts. Every time you run it, you may get a different answer. Anything built on top of those answers breaks quietly.
It sounds right when it’s not. Polished output gets approved quickly, and a wrong relationship that reads well is harder to catch than an obviously broken one.
Nobody can defend it. “The model inferred it” isn’t an answer when someone asks why a relationship exists and who agreed its meaning.
The sensible division of labour
The answer isn’t to avoid AI, but to focus it on what it’s good at.
People define meaning. A stable, reviewed set of definitions, covering what each relationship is called, which way it points and what it can connect, is the foundation. It changes slowly and deliberately.
AI does the heavy lifting within those definitions. It classifies records, proposes which relationship applies and flags things that don’t fit, and it does so at scale. Because the definitions are fixed, its suggestions can be checked: if a proposal connects things the rules don’t allow, it is rejected automatically.
When AI finds something new, it asks. A concept that doesn’t fit is raised as a proposal, reviewed by a person and then added in a controlled way. It doesn’t just appear in the model overnight.
Every inferred fact carries its history. That means where it came from, how confident the system was and who approved it.
In short, we’d recommend letting AI propose meaning but not ratify it. That step needs human review.
Summary
Simple models are easy to draw and easy to learn, and they can feel like progress. But if each line can mean five things, what you have built is a picture that looks like a model but can’t be queried like one. And if an AI invents the meanings for you on the fly, you have swapped one kind of vagueness for a faster, more confident one.
Precise meaning is what lets you ask real questions of your organisation and trust the answers. It takes more time to define, and more time to map your data against it, but that time is well spent, because the outputs become meaningful, actionable and trustworthy. Meaning that was never captured can’t be reliably recovered from the data later, by people or by AI. That is what an ontology is for: it captures meaning once, explicitly and with agreement, so that the knowledge graph built on it can be queried, reasoned over and trusted.