This piece is a response to Vimal Dwarampudi’s “Ontologies, Knowledge Graphs, and a Semantic Layer: The Architecture That Makes AI Stop Guessing”. Read his first. He is right about more than most architecture posts, which is exactly why the part he gets wrong matters.
Where the article is right
Vimal’s core claim deserves to be repeated until it becomes boring: the model should be the last step, not the first.
Large language models are extraordinary at producing fluent text and unreliable at reasoning over facts they cannot verify. If your system’s job is to be correct rather than plausible, the reasoning has to happen in structure the model cannot override: typed data, explicit constraints, validated retrieval. The LLM’s job becomes writing, not deciding.
We agree with this so completely that we compressed it into four words that govern our entire intelligence stack: deterministic by default, AI by exception. Most of what our system tells a user on any given day involves zero model calls. Signals are computed in SQL. Sentences are filled from templates. The model is invited in only where judgment is genuinely required, and even then it works inside a fence.
So this is not a rebuttal of the diagnosis. It is a rebuttal of the prescription.
The closed-world assumption
Vimal’s walkthrough is an e-commerce catalog: blue waterproof jackets, size M, two-day shipping. The ontology declares that waterproof is a valid feature for jackets and invalid for headphones. The knowledge graph holds the prices and stock levels. Everything checks out.
Notice what makes this work: he owns the catalog. The facts come from his own inventory system. The vocabulary is his to declare. The ontology is a rulebook policing data that was born inside the rules.
Now try hiring.
A job posting is free text, written by one of thousands of different applicant tracking systems, HR departments, and recruiters, in dozens of languages, with no shared vocabulary and actively misleading incentives. Titles are inflated. Requirements are aspirational. Skills are keyword-stuffed for the very parsers you are building. Some postings describe jobs that do not exist at all.
A hand-built ontology dies on contact with this world, and it dies in two ways.
The first is brittleness. The world outruns the rulebook. Every new tool, every renamed discipline, every regional job title is a gap in your meaning model, and you become the full-time maintainer of a dictionary the world has no intention of respecting.
The second is quieter and worse: silent rejection. A rigid ontology has exactly two answers, valid and invalid. Whatever does not fit the schema simply stops existing. In e-commerce that is a missing jacket. In hiring it is a person whose experience was real but phrased wrong.
The alternative: resolve, don’t build
Here is the thing the build-your-own-ontology advice misses: for many serious domains, the ontology already exists, and someone with more resources than you is maintaining it.
For skills and occupations in Europe, that is ESCO, the European Commission’s classification: thousands of occupations and skills, with typed relations between them, maintained in twenty-eight languages. For industries, it is NACE. These are not academic artifacts. They are living reference systems with institutional weight behind them, and in the European labour market they are increasingly the vocabulary that official infrastructure speaks.
So the engineering problem changes shape. It is not construct a meaning model. It is build a reliable bridge from messy human text into a meaning model that already exists. We call that layer a resolver, and it is embarrassingly simple to describe:
- Take the free-form phrase as a person or a posting wrote it.
- Embed it with an open multilingual embedding model.
- Compare against pre-embedded entries of the canonical vocabulary by cosine similarity.
- Accept matches above a tuned threshold. Cache the result.
We run the same pattern three times, in the same embedding space: free-form skills resolve into ESCO, free-form role descriptions resolve into a small set of canonical role families, and both seeker domains and vacancy texts resolve into the same NACE industry sections, so that when the system compares a person to a posting, both sides are speaking one language.
The multilingual part is not a bonus feature, it is the point. A skill written in German resolves to the same canonical concept as its English equivalent, with no translation step and no model call. The ontology handles meaning. The embedding handles the mess. Neither could do the other’s job.
The right to say “I don’t know”
This is the part textbook architectures skip, and it is the part we consider most important.
What happens when a phrase does not resolve? When the similarity score clears no threshold, when a person describes their work in words the canonical vocabulary has never seen?
A rigid ontology has no vocabulary for uncertainty. It accepts or it rejects. Most systems quietly do one of two harmful things: they force-fit the phrase into the nearest category and pretend the mapping is clean, or they drop it and pretend it was never said.
Our rule is explicit and boring: below threshold means unresolved, and unresolved is a first-class state. An unresolved skill stays exactly as the person declared it. It remains visible, it remains part of their record, it can inform scoring as context. What it can never do is get silently rewritten into something the person did not say, and it is never allowed to gate an automated decision on its own.
In a product catalog, force-fitting is a data quality bug. In hiring, it is a person being misrepresented by software they trusted. The difference between those two sentences is why we think honesty about unknowns belongs in the architecture, not in a disclaimer.
Verify after generation, not just before
Vimal’s architecture enforces the semantic contract before the model generates: validated retrieval, grounded context, constrained input. Good. Necessary. Half the contract.
Because even a model fed exclusively verified facts will still, sometimes, produce a claim those facts do not support. Fluency is interpolation, and interpolation invents.
So we enforce the contract on the way out as well. Every document our writing model drafts for a user, every CV line and cover letter claim, is checked after generation against that person’s evidence store. A claim that cannot be traced to evidence the person actually recorded gets flagged, visibly, in the interface, before a human ever decides to send the document. The person can accept the flag or fix the claim. Nothing unsupported travels silently.
Constrain before, verify after, and put a human decision between the system and the world. The model writes. The structure decides. And when the structure is not sure, it says so, out loud.
When meaning has to leave the building
There is one more scenario the private-ontology approach cannot reach, and it is the one we think matters most for what comes next.
Inside one system, a home-grown meaning model is merely fragile. Between systems, it is useless. When two agents built by different operators exchange structured data about a candidate and a vacancy, a field called skills means nothing unless both sides resolve it into the same public vocabulary. There is no bilateral treaty that fixes this. There is only shared reference.
This is why canonical ESCO keys ride the cards in our open agent-to-agent hiring protocol. A reference ontology is what turns a private semantic layer into something two strangers’ systems can agree on. If the agentic web is going to involve agents that transact rather than just talk, borrowed, public, maintained vocabularies are not an implementation detail. They are the precondition.
The amended takeaway
Vimal ends with a stack: a knowledge graph for truth, an ontology for meaning, orchestration for enforcement, an LLM for language. Keep the stack. Amend the instructions:
- Borrow the ontology. If a maintained reference system exists for your domain, resolving into it beats building your own, and in open-world domains it is the only version that survives.
- Make resolution probabilistic and honest. Embeddings bridge messy text into canonical meaning; a threshold decides; below it, the system says “unresolved” instead of guessing.
- Treat unknowns as a first-class state. Especially anywhere the data is a person.
- Verify on both sides of the model. Grounded input and checked output. Fluency is not evidence.
The systems that can be trusted are not the ones with the most elaborate rulebook. They are the ones that know exactly where their knowledge ends, and say so before the model starts talking.
Kitsuno is an EU-native, consent-first career platform built in Bucharest. The agent-to-agent protocol mentioned above, Kitso Handshake, is open at github.com/kitsuno-ai/kitso-handshake.