Lecture Four. The Cathedral: Cyc, and the Birth of the Engineering Sense.

This is the fourth of ten talks about ontologies. The first three did the word, its philosophical history, and Quine's move that turned ontology into a property of theories rather than a claim about reality. At the end of the last one I promised you the most expensive experiment this field has ever run. That's today, together with the moment somebody wrote down a definition that stuck.

Start with the premise, because everything else follows from it.

Douglas Lenat's claim was that machine learning and natural language understanding both stall without a large base of background knowledge. Learning cannot bootstrap that base, because you need background knowledge before you can interpret the examples. Reading text cannot supply it either, because the writers leave it out.

So somebody has to enter it by hand. All of it. Until the system reaches what Lenat called critical mass and can take over its own learning.

Two claims are packed into that, and they come apart cleanly. The first is that common sense is an engineering target at all — not a mystery, and not a by-product of being alive, but a body of knowledge a team can be set to work on. The second is the critical-mass hypothesis: that there is a threshold, and that crossing it hands the work back to the machine. You can accept the first and reject the second, and if you do you get a very different sort of project. Cyc is what you build when you accept both.

In nineteen eighty-four, Lenat and Mary Shepherd began that project. It was called Cyc. The article to read is Lenat's "CYC: A Large-Scale Investment in Knowledge Infrastructure," published in Communications of the ACM — the A-C-M, the Association for Computing Machinery, the main professional body of the field — in nineteen ninety-five. It is short, and it is worth reading in full. In it Lenat says something I find genuinely admirable, and I'll quote it. Mary Shepherd and I, he writes, embarked on that task in nineteen eighty-four, "knowing we had little chance of success, but seeing no alternative but to try." That is not the sentence of a man overselling his research programme.

What does codifying common sense require? Lenat's list is sobering. Causality. Time. Space. Substances. Intention. Contradiction. Uncertainty. Belief. Emotion. All of that has to be represented before a machine can reason about anything ordinary at all.

The examples in the paper are the part people remember, and they're worth hearing, because they show exactly what kind of knowledge is at stake.

You cannot remember events that have not happened yet.

If you cut a lump of peanut butter in half, each half is also a lump of peanut butter. But if you cut a table in half, neither half is a table.

Sit with that second one. What I'm about to say about it is my reading rather than Lenat's. It is the distinction between mass nouns and count nouns, and what it decides is whether half of a thing is still an instance of the thing's type. Any system reasoning about materials, or chemicals, or fuel, or blood needs that distinction, and needs it written down, because it does not fall out of anything else.

Lenat's own line about why counting words will not get you there is worth quoting directly. Statistics, colocation, and frequency, he writes, "do not resolve such questions. But the task goes from impossible to trivial if one already knows a few things about boxes and pens."

So how big did it get? The nineteen ninety-five paper reports a universal schema of roughly a hundred thousand general concepts spanning human reality, about a million commonsense axioms handcrafted for and entered into Cyc's knowledge base, and millions more inferred and cached by Cyc itself. And it reports a price: a person-century of effort since nineteen eighty-four.

Hold that number, because it is the only one of its kind. This is the only document I know of that states the price of hand-codified knowledge as a figure. Every plan that says "we'll just model our domain properly" is quietly betting against it. Because underneath every one of those plans sits the question every ontology project eventually has to answer: how much of the world do we have to write down before the model earns its keep? Cyc is the largest sustained attempt anyone has made to answer it, which is why it is the reference experiment for the cost side of this whole discipline.

Cyc also introduced an idea that has aged well. Micro-theories. Each one, in the paper's own words, "inhabits its own context," and each is "relatively small, solid, and flat." Now, the reason I think that matters is mine and not the paper's, so take it as my inference. Demanding that one enormous knowledge base be consistent from end to end is a losing requirement. Small, flat, locally coherent contexts are a way of not asking for it.

What happened to the project? Cyc is still going, and it is sold today as a commercial platform — machine reasoning built on codified human common sense rather than on patterns and statistics. Where it is sold is the part that would surprise a reader of the nineteen ninety-five paper. The emphasis now is healthcare operations. Charge capture. Denial management. Post-acute-care forecasting. Staffing. The offer is a knowledge and reasoning layer placed over complex operational workloads, using continuously enriched patient and order context to make auditable decisions. The capability list runs: logic-based machine reasoning, codified common-sense knowledge, dynamic real-world data, semantic context, autonomous decision-making. And it is pitched hard on explainability and auditability.

I want to hand you that description with a warning attached, because I am reading it off the company's own page. It makes broad product and performance claims, and it supplies no ontology structure, no evaluation details and no implementation guidance, which means none of those claims can be assessed from that source alone. Take it as positioning. It tells you what the market is willing to buy from a knowledge base, which is genuinely informative, and it tells you nothing about whether the thing works.

What Cyc never reached is the critical mass Lenat described, where the hand entry stops and the system reads for itself. The payoff was always deferred to a threshold that had not yet arrived.

And I want to draw the engineering lesson carefully, because it's easy to be glib about a project that has run for forty years.

The lesson is not that the effort was wasted, and it is not that hand-built knowledge is worthless. The lesson is about the shape of the bet. A knowledge base whose value depends on reaching a threshold, rather than on being useful at every stage, is a bet on the threshold. The alternative shape is layered: a small ontology that answers real competency questions early, and keeps answering more of them as it grows. When you plan a knowledge project, ask which of those two shapes it has. If the answer is "it'll be great once we've modelled everything," you have a Cyc, and you should know that going in.

Now, the second half of this lecture, and the reason the word we're studying entered computer science at all.

Tom Gruber's nineteen ninety-three work gave us the definition: an ontology is an explicit specification of a conceptualization. We took that apart in lecture one, so I'll only restate what matters here — and what matters here is where he was standing when he wrote it. Gruber's own acknowledgements place the work inside the ARPA Knowledge Sharing Effort. ARPA is the Advanced Research Projects Agency, the American military research funder, later renamed DARPA with Defense on the front. And the operative word in that programme's name is sharing.

Read the definition next to the name of the programme and the shape of the thing becomes obvious. Gruber's ontology is an interface specification. It is the language two agents use to talk to each other about a domain, and — this is his sentence — "the agents sharing a vocabulary need not share a knowledge base; each knows things the other does not." An agent that supports the interface is not obliged to store its knowledge that way internally at all.

That is why an ontology can sit on top of systems that share nothing else. Two teams, two internal representations, neither of which is going to be rewritten. What do they have to agree on? Not their code. Not their storage. The vocabulary, and a written-down account of what the vocabulary means, explicit enough that a machine can check it.

Hold on to that shape, because it recurs. Palantir describes its own Ontology in almost the same architectural words — it sits, in the company's own phrasing, on top of the digital assets integrated into the Palantir platform, and connects them to their real-world counterparts. On top of, and connected to. Not in place of. Palantir never invokes Gruber, so what I am pointing at is a resemblance and not a lineage, and lecture nine is where we take it apart properly.

That agreement has a name in this literature. Ontological commitment. In lecture three it was a formal object. In Gruber's engineering register it is something plainer than that: an agreement to use a vocabulary consistently.

In nineteen ninety-seven Willem Borst revised the definition to "a formal specification of a shared conceptualization." That word, shared, adds consensus. And I'd say the addition is really the original mission catching up with the sentence: an ontology only one team agrees with does not solve a sharing problem.

So of the words in that definition, two carry the weight. Explicit — the commitments are written down and machine-readable. And, after Borst, shared — more than one party agreed to them.

I don't want to leave that sentence looking tidier than it is, though, because the field's founding definition is also the field's longest-running argument, and Gruber knew it. He concedes in his own writing that the terms specification and conceptualization have, and I quote, "caused much debate." Guarino, Oberle and Staab — whose formal construction of commitment we met in lecture three — wrote their two thousand and nine chapter largely to repair that informality, on the grounds that all the earlier definitions were assuming, as they put it, an informal notion of conceptualization.

The instability goes all the way down to the wording, and it is worth being precise about that. In lecture one I gave you the conceptualization half of the definition as the objects, concepts and other entities presumed to exist in some area of interest, and I flagged there that this is Gruber's own restatement of himself, from two thousand and nine. Genesereth and Nilsson's original says assumed to exist, not presumed. Nothing much hangs on the difference. What hangs on it is the fact that the field's most-quoted sentence circulates in more than one authorised wording, and almost nobody who quotes it has ever had to decide which one they mean.

And there is a standing objection that Gruber records and then rejects. The objection is that the definition is overly broad, allowing, in its words, "a range of specifications from simple glossaries to logical theories couched in predicate calculus." Whether that breadth is a defect is still argued. What is not in doubt is the practical consequence: it is exactly what lets a team call any schema they like an ontology. Keep that in your pocket. It explains a great deal of what you will hear the word used for.

There's one more strand feeding into this moment, and it's the one that makes the artifact computable. Description logics. They are a family of formal knowledge-representation languages, more expressive than propositional logic and less expressive than first-order logic, built out of concepts, roles, individuals and axioms, and deliberately balanced so that expressive power is traded against the cost of reasoning. Many of their core reasoning problems are decidable — meaning a program is guaranteed to stop and give you an answer rather than running forever. Description logics are the logical foundation of OWL, the Web Ontology Language, and of its profiles, and they are the whole subject of lecture six.

The trade behind those profiles is a single sentence. Adding operators, and letting the concept hierarchy get more complicated, usually increases the computational complexity of inference. Profiles are what you get when a standards committee takes that sentence seriously.

Two more things about that family before we leave it, because "makes the artifact computable" is a promise until you have seen what it consists of.

The first is a translation table, and it is shorter than you would expect. A concept corresponds to a class, or to a unary predicate — something you assert of one thing. A role corresponds to a property, or to a binary predicate — something that relates two things. An individual corresponds to a constant. Three slots, and that is the whole apparatus.

The next step is my reading rather than the source's, so take it as mine. Those are the same three slots lecture three's criterion cares about. Gruber wants two agents to agree on a vocabulary. Quine wants you to read a theory's commitments off what it quantifies over. Description logics say the vocabulary is predicates and constants, and then hand the lot to a machine. So the engineering tradition and the philosophical one are not merely being polite to each other in this lecture. They are describing one structure from opposite ends.

The second thing is reach. Description logics turn up in ontologies, in the Semantic Web, in biomedical informatics, in defence, in climate modelling, and in industrial knowledge graphs. Six fields with almost nothing in common except the need to state what kinds of things exist and how they relate, and the same small formalism sitting under all of them. I'd take that as the fair measure of how load-bearing this quiet idea turned out to be.

So two traditions meet in the early nineties. From the artificial intelligence side, Cyc's hard-won verdict that background knowledge is the bottleneck, plus a formal apparatus for computing over concept descriptions. From the systems side, a funding programme whose goal was reuse. Ontology, in the engineering sense, is the artifact where those two meet.

Let me put Cyc back on the table one last time, because it has become relevant again in a way that would have surprised everyone in nineteen ninety-five.

Cyc's motivating claim is that statistics alone will not resolve commonsense questions. That is precisely the claim large language models contest most directly, because they absorb an enormous amount of exactly that background from text, and nobody hand-wrote a single axiom to put it there. The paper is from nineteen ninety-five and says nothing about them — it could not. It is nevertheless the thing everyone is arguing with. Every later dispute about whether a model can replace an ontology is, whether it cites the paper or not, a dispute with that one sentence about boxes and pens.

The counter-argument I'd make is mine, not Lenat's, and I want to flag it as mine. What the axiom gave you that the model does not is three properties. It is inspectable: you can read it. It is consistent, in the sense that a reasoner will tell you when it contradicts another axiom. And it can be audited — you can ask where it came from and why. What a model absorbs has none of those three. Notice, incidentally, what Cyc sells on commercially today: explainability and auditability. Not coverage.

So the honest position, as I read it, is that Lenat may have been wrong about where the background knowledge would come from and right about what you lose when it arrives any other way. The field is still working out what to do with that split verdict, and we end the series on it.

So, the claim to keep.

The computer-science sense of "ontology" was invented to solve a sharing problem between knowledge-based systems, not a reasoning problem. That is why an ontology is an interface specification rather than a storage format, and why the definition eventually acquired the word "shared." And the field's founding megaproject, Cyc, bet everything on a critical mass it never reached — which makes it the standing warning about knowledge work whose payoff sits at a threshold instead of arriving in increments.

Next time, the moment this quiet engineering discipline was handed the entire World Wide Web.