Chapter 4: The Graveyard
The field has conducted its post-mortems before, and the verdicts are on record: the rules were too brittle, the standards too complex, the tooling too immature, the authoring too expensive. Each verdict is locally true and collectively useless, because it explains each death in its own terms and leaves the survivors unexamined. Treat the record instead as a single natural experiment — forty years of organizations representing their own knowledge, in forms that lived or died — and put to every artifact the same question: not how expressive it was, nor how rigorous, but what happened when it went stale. Asked that way, the record stops being a collection of cautionary tales and starts yielding a pattern.
I. The Rule Bases
The first serious attempt to make knowledge executable was the expert system. At Stanford in the mid-1970s, MYCIN diagnosed bacterial infections from a base of several hundred hand-written rules, and in blinded evaluation it performed on par with the specialists it was modeled on; it never entered clinical routine, but it set the ambition for a decade — if expertise could be written down as rules, expertise could scale. The ambition scaled in both directions. At Digital Equipment Corporation, XCON configured customer orders for VAX systems from thousands of rules and sat squarely on the revenue path. And Douglas Lenat’s Cyc project, begun in 1984, pushed toward the logical maximum: encode not one specialty but common sense itself, assertion by hand-written assertion, millions of them, across what became four decades of patient labor.
The boom ended in the usual way, and the standard autopsy blames what Edward Feigenbaum named the knowledge-acquisition bottleneck: extracting rules from experts was slow, expensive, and unending. True — but the bottleneck explains the cost of the program, not the pattern of what survived it. Ask the stale question instead and the pattern is sharp. Where rules sat on a consequential path, they were maintained: XCON was famously expensive to keep current, and it was kept current, for years, because a wrong rule shipped a mis-configured system to a paying customer — divergence had a return address. Where rules sat off any such path, nothing in the environment signaled their staleness; a human expert had to notice, on their own initiative, that the world had moved — and humans reliably notice what costs them, not what quietly stops being true. The expert systems era proved that knowledge could run. What it could not do was make knowledge scale, because keeping the rules true was manual labor everywhere the environment failed to supply a signal.
II. The Unified Models
The integration crises of the 1990s and 2000s produced a different artifact: the canonical data model, a peace treaty among systems. One definition of Customer, one of Order, one of Product, to which every application would map — the idea being that a company with forty systems and one model pays for forty translations instead of sixteen hundred. Enterprise architecture practices grew around the treaty: modeling tools, review boards, reference diagrams of impressive draftsmanship.
The record of these models is the cleanest controlled comparison in the whole graveyard, because the same artifact class met two fates in the same organizations, in the same decades, drawn in the same notations, often by the same architects. Where the canonical model was compiled — generated into message schemas, enforced by validation at system boundaries, wired into builds — a violation broke something: the build failed, the message bounced, the deploy stopped. Those models were maintained, grudgingly but continuously, for as long as they governed. Where the model lived in the modeling tool as reference material — consulted at design reviews, printed for the wall — it drifted within a budget cycle or two, ending as an ornate diagram of a company that no longer existed. Everything the official explanations point to was held constant: expressiveness, tooling, funding, talent. The variable that sorted the fates was whether anything, anywhere, failed when the model went wrong.
III. The Cathedral
The Semantic Web deserves to be treated with respect, because technically it was the most accomplished attempt ever mounted. The 2001 vision — Berners-Lee, Hendler, and Lassila, writing in Scientific American — imagined a web of machine-readable meaning, and the machinery delivered over the following years was genuinely superb: RDF for stating facts, OWL for defining vocabularies with formal semantics, description-logic fragments chosen with care so that reasoning would remain decidable, global identifiers so that any concept could be referenced from anywhere. Serious logicians did serious work. The expressiveness exceeded what almost any enterprise needed — exceeded, in fact, what almost any enterprise could staff.
Adoption failed in the large anyway, and the standard diagnosis is economic: authoring ontologies was expensive, the benefits were speculative, and the chicken-and-egg never resolved — no data without applications, no applications without data. The diagnosis is correct as far as it goes, but the stale question goes further. The missing party was not the author but the consumer: nothing read the ontologies at runtime in a way that made their wrongness cost anyone anything. An ontology could drift arbitrarily far from the domain it described and no build would break, no message would bounce, no customer would call. Nothing failed when an ontology went stale — and so, by the pattern this chapter is assembling, ontologies were documentation with better syntax, and they decayed at documentation’s rate. The project had assumed, without ever stating it, the serene physics of the first chapter: build the true model, and its truth will keep it.
IV. The Exceptions
Two artifacts from the same lineages refused to die, and their survival is more instructive than any of the deaths. The first is schema.org, launched by the major search engines in 2011: a vocabulary for embedding typed markup in web pages, a direct descendant of the Semantic Web family, simplified almost to the point of insult by comparison with OWL. It thrives — deployed across a substantial fraction of the web, maintained, versioned, extended. The difference is not the notation. The difference is that a consumer existed from the first day: the crawler read the markup, and conformance was rewarded observably, in rich results and traffic. A publisher who marked up wrongly lost something visible and knew it. Note the sign of the consequence: nothing breaks when schema.org markup is wrong; something is forgone. Enforcement by reward turns out to work as well as enforcement by breakage — what matters is that the consequence is observable, not which direction it points.
The second exception is the digital twin: a model of a physical asset — a turbine, a pipeline, a production line — synchronized with live sensor telemetry. Twins have proved durably useful precisely where the synchronization is real, and the reason is structural: the sensor stream makes divergence between model and reality observable by default. A twin that drifts from its turbine announces the drift, continuously, in data; the repair loop is built into the artifact’s operating condition rather than left to anyone’s initiative. This is the same property the compiled canonical models had, achieved by instrumentation instead of compilation. Between them, the two exceptions triangulate the rule: durability appears exactly where conformance is observably consequential — by breakage, by reward, or by telemetry, indifferently.
V. The Control Group
The strongest evidence in the record comes from two artifacts that nobody entered in the knowledge-representation category at all — which is itself part of the finding. Source code and database schemas are maintained with the highest fidelity of anything an organization keeps, decade after decade, across total turnover of the people involved. The COBOL written in 1985 still executes the business rules of 1985, correctly, under engineers who were not born when it was written; the schema is migrated with an archaeologist’s care, column by column, because everyone involved understands that a careless change loses real data for real customers. And neither artifact can claim the virtues the graveyard’s casualties were built on. A relational schema is expressively impoverished next to OWL — it cannot state most of what an ontology states. Code is not a declarative representation of the domain at all; its domain content is smeared through control flow and infrastructure. On every official axis — expressiveness, formality, semantic rigor — the control group is inferior to the casualties. It outlives them anyway, because both artifacts share the one property the casualties lacked: when either diverges from intended reality, something visible breaks. A compile, a test, a write, a customer. The failure triggers the repair, locates the repair, and confirms the repair by disappearing.
Line the five cases up and sort them. Sort by expressiveness and the record scrambles: OWL outclasses everything and is the deadest artifact on the list. Sort by formality, by tooling, by funding, by the talent of the people involved, and the record scrambles again — the casualties had more of each than the survivors. Sort by a single unglamorous variable — did anything fail observably when the artifact went stale? — and the record falls into order without remainder. The rules that touched revenue survived. The models that compiled held. The ontologies, consumed by nothing, died. Markup lived on reward, twins on telemetry. And code and schemas, the least expressive artifacts in the study, outlived everything. A pattern that clean deserves a precise statement, a mechanism, and a name. The next chapter gives it all three.