Why Agentic Systems Need
Ontologies

No. Hallucination is a property of the probabilistic substrate, not a defect to engineer out: a language model samples from a probability distribution over what comes next, and 'novel and correct' is reasoning while 'novel and wrong' is hallucination — same machinery, same operation. A model constrained to emit only what it has literally seen is a lookup table; you cannot remove the capacity to be wrong without removing the capacity to imagine a better world. You design around properties; you don't apologize for them.

Because both are the same operation judged by outcome: sampling from a probability distribution in multi-dimensional space over what comes next. The only difference between reasoning and hallucination is whether the output happened to land inside the truth. The capacity to combine things never combined — a sentence no one has written, an argument no one has made — is the entire reason these systems are worth building.

Sequential reliabilities multiply, they don't average: an agent right 99% of the time chained five-deep lands at about 95.1% end to end, and the exponent is the length of the workflow. Nobody's intuition works this way: we estimate an excellent pipeline as excellent, when the correct operation is exponentiation.

0.99 to the hundredth is about 0.366 — a hundred-step workflow of 99%-per-step agents succeeds end to end about 36.6% of the time, failing nearly twice as often as it succeeds. At 95% per step it collapses to about 0.6%, roughly one success in 170 attempts. It doesn't degrade; it collapses.

Halving the per-step error rate from 1% to 0.5% moves a hundred-step workflow from 36.6% to about 60.6% end-to-end success — nearly doubling the outcome from a change most teams would wave off as marginal. That is the exponential working in your favor, and the argument for spending real engineering money on step-level reliability instead of hoping a retry loop covers it.

At the step that produced the error, not at the end. Validation that lives only at the end of the pipeline is forensics: a bad entity enters at step two and every later step faithfully reasons over garbage. The cheapest place to catch an error is the moment it appears.

Two dimensions worth separating: a shared understanding of the domain (entities, relationships, the vocabulary of what exists and how it connects — forcing the team to agree on what a customer or a claim is before anyone writes a prompt), and logical constructs that act as guardrails (RDFS/OWL domain and range, cardinality, disjointness, class hierarchies with inferential teeth) that agent output is grounded against.

The guardrail layer doesn't weigh evidence and can't be talked into anything: it sits outside the model, acting as a guardrail between the agent and the consequences, and it either passes or it doesn't. That determinism within a bounded domain is exactly what makes it a complement to a probabilistic generative core.

The pairing of probabilistic generation with symbolic verification: LLMs supply fluency and the ability to handle open-ended, messy input, while symbolic systems supply certainty within a bounded domain. Neither does the other's job well, which is precisely why the combination works — the architectural answer to the chain-reliability arithmetic.

Expert systems failed because the thing being modeled was unbounded: CYC spent decades hand-encoding common sense in a complete symbolic model of everything a person knows, and it didn't scale. What changed is the scope of the ask — a bounded set of rules and OWL constructs for one domain, constraints in the dozens or hundreds rather than the millions — and authoring cost, since an LLM can read a corpus, propose structure, and draft the tedious parts for a human to correct.

They translate structured data into natural-language insight without SPARQL, integrate and mesh data across disparate sources, anchor AI outputs to RDF knowledge graphs (mitigating hallucinations), and support follow-your-nose navigation across triples. Mosaic and Mozilla/Netscape made the document Web usable; LLMs are the analogous client that makes RDF actionable.

Its core ideas were never flawed — entity naming via HTTP URLs was solved from the start, and relationship representation formats matured — but the absence of usable interfaces stalled it. LLMs and tools like OPAL supply the missing half: natural language translated into SPARQL, SQL, or GraphQL, with answers as charts, tables, or property sheets. The Semantic Web didn't fail; it needed AI as its yin-yang complement.

A queryable behavioral contract for AI agents encoded as RDF-Turtle: a shared store of core.ttl, preferences.ttl, index.ttl, howto documents, and session files that agents must read before tasks and write back after them. It is a working instance of an ontology-grounded agent contract — the essay's 'symbolic guardrails outside the probabilistic core' — built on the Semantic Web's own machinery: RDF, dereferenceable IRIs, and queryable structure.