The Rule, and the Month That Breaks It

Part 3 gave the spine an early-warning system: watch the query logs and the schema changes, let a model draft the candidate update, put it in front of a steward. Part 5 named the agents that do it and stated the rule plainly — agents propose, humans approve. I made the same split again outside this series, in Your Data Strategy Is Already Dead, where agents draft remediations and humans approve them — and attached a note I have been carrying ever since: that division will shift over time, but it starts there.

This is where it shifts. I still hold the rule; I no longer believe it covers the whole surface. The series supplies the rule under examination. That article supplies the sensing layer and the impact machinery I am not going to rebuild here.

Start with the arithmetic that ends it. A semantic working group meets on the second Thursday of the month. Nine people, ninety minutes. This month they cleared eleven definition changes — a good month, because two of them were contested and got settled instead of deferred again.

In the same thirty days the estate underneath them absorbed a new billing platform, three schema migrations in the core lending system, a regulatory change that redefined a threshold, and forty tables a data science team stood up in the lakehouse because they needed them by Friday.

Eleven, against all of that. Nobody in that room is underperforming. The queue is simply arriving faster than the approval step can drain it, and it has been for years — the difference is that humans used to absorb the shortfall invisibly. An analyst noticed the number looked off. A modeller remembered why the join was there. That cover is gone: agents have no tribe, and where meaning is unwritten they do not hesitate, they interpolate.

Semantic change accrues continuously. Approval lands in discrete committee-sized steps. Better drafting raises the step height; it does not change the shape.

Two Reasons the Queue Never Drains

Scale. Curation cost does not scale with the number of terms. It scales with the number of bindings — every physical place a concept is realised, every metric claiming to compute it, every document referencing it, every tool contract exposing it. Add a system and you do not add one binding; you add edges to everything it touches. Terms grow linearly. Bindings grow with the square of your estate’s ambition. The working group is sized for the first and accountable for the second.

This is the change-propagation argument on a different axis. There, the point was that cost scales with the rate of change rather than the size of the estate. Here, it scales with the binding surface rather than the term count. Both say the same thing: the number you are counting is not the number that is growing.

Time. Even fully staffed, batch approval has the wrong shape. Meaning is now read at runtime, thousands of times a day — and Gartner expects more than half of AI agent systems to be running on context graphs by 2028, which makes this the normal consumption pattern rather than the advanced one.1 A definition that is six weeks stale does not throw an error. It renders. It answers. It gets quoted in a memo.

The instinctive response is the one Part 3 already proposed: make the drafting faster. That is where most enterprises now are, and it does not close the gap, because drafting was never the constraint. Approval is. And approval neither parallelises nor compresses.

The Number That Broke the Rule for Me

We now have a measurement of how good that approval step actually is.

In a controlled study, nineteen ontology engineers judged whether an ontology correctly modelled a requirement. Where the machine suggestion was correct, they went from 70.5% unaided to 83.2% assisted. Where it was incorrect, they went from 71.9% to 43.9% — a 28-point collapse. Thirteen points up, twenty-eight down, and an overall difference the study reports as not statistically significant.2

Read the last two numbers together. Human approval is not a safety net that catches machine error. It is a component with its own error rate, and that rate degrades in the presence of confident wrong suggestions — which is precisely the output profile of the thing it is meant to be checking.

So “a human approves it” is a governance sentence, not an engineering control. It is a real control for the forty contested terms, where the human is not checking a fact but exercising authority. It is theatre at the volume surface, where thousands of low-stakes bindings a month meet a reviewer who is now assisted by exactly the system most likely to walk them into the 44% case.

Autonomy Is a Property of the Tests, Not the Generator

The objection to autonomy is correct as stated. Turn a model loose on the estate and you get what the literature reports: a 2026 systematic review of thirty studies and forty-one experiments found effort concentrated overwhelmingly on initial construction and 2.4% — one study — on maintenance, with recurring violations of disjointness, hierarchy direction, and domain and range constraints.3 An enterprise pipeline the same year scored a fuzzy-matched F1 of 0.72 in one domain and 0.12 in another — same method, same models — and near zero everywhere on exact matching.4 Nor does waiting help: across thirteen models, the effect of scale on ontology learning was non-uniform and architecture-dependent, with a mid-sized dense model beating far larger sparse ones on some tasks.5

Now hold that against the same capability placed inside a loop with real tests. Retrieve only the relevant fragment of the existing ontology; drive every proposal from an explicit competency question; force the output through a validator, a reasoner, a pitfall scan, and a SPARQL query that must actually return the answer the question demanded. Across 39 competency questions in two use cases, that configuration produced syntax errors in at worst 2.5% of cases — none at all in one of the two — with 100% competency-question coverage and under 2% superfluous elements, against roughly 30% in open-ended generation. Expert reviewers rated the industrial ontology 4.5–4.9 out of 5.6

Same models. Two orders of magnitude of usable quality. The variable was not intelligence.

Autonomy is not a claim about how smart the generator is. It is a claim about how good the tests are.

An ontology can be maintained autonomously exactly to the extent that its correctness conditions are machine-checkable — and the engineering work is moving conditions from the second category into the first.

The same result marks its own limit. On the project whose competency questions were ambiguously worded, expert ratings fell to 2.9–3.7. Where the requirement was vague, the loop degraded — as it should. Autonomy inherits the precision of its specification, which is something you can manage. Model reliability is not.

What the Earlier Articles Already Gave Us

Two of the six components in the architecture below are already built and already argued.

Sense is Part 3’s semantic observability — SHACL violations, failed queries, workaround behaviour — extended in Part 5 by the Sentinel patrolling logs and schema changes, and built out properly in Your Data Strategy Is Already Dead as four capture tiers placed on the choke points where change already leaves fingerprints. I am taking that layer as given, under its name there. Add one input none of them named: the agent runtime itself. Every clarification an agent had to ask, every refusal, every “I don’t know which definition applies” is a semantic requirement arriving with a use case already attached. It is the highest-signal queue in the architecture and almost nobody reads it.

Proposing is Part 5’s Builder, with one constraint tightened: it emits a typed delta against the existing spine, one competency question at a time. Never a regenerated ontology. Whole-model regeneration is how you lose a decade of arbitration in a single commit.

That is the inherited half. The three components that follow are the new argument.

Verify: The Gauntlet

Nothing reaches a human until a machine has tried to falsify it. The stages run in ascending order of cost — syntax, shapes, reasoner consistency, pitfall scan, competency-question execution against live data, superfluity, then regression against the golden set. Failures do not merge; they annotate the proposal with the specific failing test, which is what makes the next iteration cheap.

Part 5 said validation becomes the gate. This is what the gate is made of, and the order matters as much as the contents: human attention is the scarcest resource in the system, and spending it on candidates a machine could have rejected is the most expensive habit in the discipline.

One distinction is worth drawing, because both loops discover by exception and readers of the change-propagation piece will otherwise collapse them. That reconciliation loop checks declared bindings against observed reality. This gauntlet checks proposed meaning against its stated requirements. Different objects, same discipline: investigate the disagreement, and let the agreement cost nothing.

Ascending order of cost. The test that matters is fifth: does the question this element claims to answer actually return an answer?

Arbitrate: Route by Contestation, Not by Confidence

Part 5 scaled autonomy by groundedness. I would now scale it by something the organisation declares rather than something the model reports.

A definition can be vague — fixable by precision, safely automatable. Or it can be contested — two executives, two incentives, one word, and no volume of evidence settles it, because the disagreement is not epistemic. Model confidence cannot tell these apart, and groundedness cannot either: the fight over “active customer” is perfectly well grounded on both sides. Contestation is a property of your politics, declared in advance, and it routes to a named owner every time.

This is where the sizing claim from Part 1 stops being rhetoric and starts being load-bearing. The forty terms that carry enterprise weight are contested; forty is a volume humans can sustain, and propose-and-approve is exactly right for them. The bindings, extensions, tags and resynchronisations attached to those forty are thousands of decisions a month, individually low-stakes, collectively decisive, and overwhelmingly uncontested. That is where fossilisation actually happens, and it is where the loop belongs.

The contested core is arbitrated and stays small. The extension and binding surface carries the volume, and it is what autonomy is for.

Measure: Autonomy Earned, and Revoked

Every auto-merge is a prediction. Sample them, score them, and let measured precision per region of the spine set how much autonomy that region gets. A surface that regresses loses its dial automatically and returns to review without anyone convening.

This is the component that makes the whole thing defensible to a regulator, and it is the one most programmes skip. You are not asserting that the machine is right. You are producing the measurement of how often it has been, and the control that responds when it stops being.

Sense, propose and publish were argued in Parts 3 and 5 and in “Your Data Strategy Is Already Dead.” Verify, arbitrate and measure are the argument of this one.

Four Principles Worth Stating Flatly

  1. Nothing enters without a question it answers. Requirement-first generation is what makes “is this superfluous?” a failing test rather than an opinion.
  2. Nothing merges without provenance to an observed artifact — a schema, a log, a contract, a ticket. “The model proposed it” is not provenance. Ungrounded proposals are emitted as gaps, not queued as work.
  3. The proposer is never the verifier, and the verifier is not a second opinion of the same kind. An LLM checking an LLM’s axiom shares the failure mode. Symbolic where possible; independent where not.
  4. Every change is versioned, reversible, and blast-radius-checked before merge. The traversal that computes the blast radius already exists as Layer 4 of the change-propagation architecture, bounded by the affected neighbourhood rather than the size of the estate. A semantic change enters it as one more delta. And a change that cannot be rolled back is not a change — it is an incident with a lead time.

What To Do on Monday

Weeks 1–4. Take twenty terms your agents already get wrong. Write the competency question and the SPARQL that proves each one. That is a semantic regression suite, and it is useful before any autonomy exists.

Weeks 5–8. Build the gauntlet and leave generation manual. Then run your existing ontology through it. The failure list will be the most honest measurement your programme has produced in years.

Weeks 9–12. Close the loop on one surface — binding maintenance for a single domain, say. Auto-merge nothing yet; measure the pass rate and the sampled precision. When it holds for a month, turn the dial one notch.

Note what you have not done: asked anyone to trust a model. You have built the instrument that decides how much to trust it, per surface, on evidence, reversibly.

The Deadline Nobody Has Priced

Agents are not only the consumers of your semantics. They are becoming the producers of change in the estate — writing the pipeline, altering the schema, standing up the dataset, at a cadence no working group can convene for. An estate whose meaning is maintained in ninety-minute monthly increments has no chance of describing an estate that machines are modifying continuously.

Gartner’s prediction that more than 40% of agentic AI projects will be cancelled by the end of 2027 will be told as a story about models and cost.7 A meaningful share of it will be this.

Part 5 ended by saying your agents do not need more intelligence, they need a spine. That still holds. What I would add now is that the spine does not need more approval either.

It needs tests.

When a definition in your organisation becomes wrong, what finds out first — a test, or a customer?

Sources

The Knowledge Spine series: Part 1 (the backbone), Part 2 (the blitz), Part 3 (the living spine), Part 4 (the balance sheet), Part 5 (the agentic spine), Bonus (the field manual). This is Part 6. Adjacent, and assumed throughout: Your Data Strategy Is Already Dead, which supplies the sensing layer and the impact traversal this part builds on rather than repeats.

Footnotes

  1. Gartner: more than 50% of AI agent systems are expected to leverage context graphs by 2028, with 80% of the tools used to build AI applications shipping context-engineering features by the same year. Summarised in Gartner on Context Graphs: Trends, Capabilities, Setup in 2026 (opens in a new tab). ↩

  2. Lippolis, Saeedizade, Keskisärkkä, Gangemi, Blomqvist & Nuzzolese, Large Language Models Assisting Ontology Evaluation (OE-Assist), arXiv:2507.14552, July 2025. Nineteen ontology engineers from eight institutions, 20 tasks each. Accuracy is reported conditional on suggestion correctness, so the two conditions have separate baselines: 70.5% → 83.2% where the suggestion was correct, 71.9% → 43.9% where it was not. Overall assisted 0.76 vs unassisted 0.72, not statistically significant. Best automatic model reached 0.66 macro-F1, comparable to average human performance. arxiv.org/abs/2507.14552 (opens in a new tab) ↩

  3. Li, Garijo & Poveda-Villalón, Large Language Models for Ontology Engineering: A Systematic Literature Review, Data Intelligence (SAGE), 2026. Thirty papers, forty-one experiments; 63.4% implementation, 24.4% requirements, 9.8% publication, 2.4% maintenance; documented violations of disjointness, hierarchy and domain/range constraints; no standardised metrics per task. semantic-web-journal.net (opens in a new tab) · doi.org/10.1177/22104968261465514 (opens in a new tab) ↩

  4. Oyewale & Soru (Liber AI Research), LLM-Driven Ontology Construction for Enterprise Knowledge Graphs (OntoEKG), arXiv:2602.01276, February 2026. Fuzzy-match F1 of 0.724 (data), 0.431 (logistics), 0.121 (finance); structured-output guardrails insufficient to prevent hierarchy inversion and class/individual confusion. arxiv.org/html/2602.01276v1 (opens in a new tab) ↩

  5. Babaei Giglou, Auer & D’Souza, When Does Bigger Help? A Controlled Study of LLM Scale for Ontology Learning, arXiv:2608.31118, August 2026. Thirteen models across the Qwen3.5/3.6 dense and Mixture-of-Experts families plus proprietary GPT releases; the effect of scale is “neither monotonic nor uniform across tasks and domains,” and dense 27B models outperformed substantially larger sparse ones on term typing. arxiv.org/abs/2608.31118 (opens in a new tab) ↩

  6. Lippolis, Saeedizade, Schmid, Blattner, Keskisärkkä, Gangemi, Blomqvist & Nuzzolese, OntoExtend: A Framework for Requirement-driven and Scalable Ontology Extension with LLMs, 2026. Retrieval plus competency-question-driven generation with Turtle/SHACL validation, OOPS! pitfall scanning, Pellet consistency checking and SPARQL-based verification, over 39 CQs across an EU-project ontology (20) and a Bosch industrial ontology (19): 0% and 2.5% syntax errors respectively, all CQs correctly modelled, under 2% superfluous elements against roughly 30% in the same group’s prior method; expert Likert means 4.54–4.96 (industrial) and 2.94–3.69 (EU project, ambiguously worded CQs). arxiv.org/pdf/2607.17963 (opens in a new tab) ↩

  7. Gartner, June 2025: over 40% of agentic AI projects will be canceled by end of 2027 (opens in a new tab). Related: through 2026, organisations are predicted to abandon 60% of AI projects unsupported by AI-ready data (Gartner, February 2025 (opens in a new tab)). ↩