Why Agentic Systems Need Ontologies (Frank Coyle, AI Engineer)

Talk by Frank Coyle at the AI Engineer World's Fair 2026 (~20 min, YouTube via AI Engineer channel). Coyle is a UC Berkeley computer science educator whose earlier career was in neuroscience and expert systems; the talk uses that vantage to argue that agentic AI is quietly rediscovering symbolic AI's guardrails, and ontologies are the missing validation layer around the ReAct loop.

The two-lineage framing

Coyle opens by tracing two independent histories that are now converging:

Agents. From John McCarthy, Oliver Selfridge, Marvin Minsky (Society of Mind) and the 1956 Dartmouth workshop where "artificial intelligence" got its name → today's agents that perceive, decide, act.
Ontologies. From Aristotle's Categories ("philosophy of being") → Willard Van Orman Quine → Tom Gruber, 1993: an ontology is "a formal specification of a shared conceptualization" → today's knowledge graphs.

The convergence is what people are now calling neuro-symbolic AI (see Neuro-Symbolic AI): probabilistic neural networks (the agents / LLMs) tied to formal symbolic representations (the ontologies).

"What I'd like to argue is that neuro-symbolic AI sort of represents a way to keep the LLM on its guardrails, because LLMs are by nature probabilistic. People worry about hallucinations, but that's the feature. That's actually a feature of large language models."

What an ontology actually is

Coyle keeps the definition tight (see Ontology for the standalone concept page):

Graph-shaped: entities + relationships + properties.
Not a relational schema. Adding a new fact to a relational database means altering the schema and reshaping every row. Adding a fact to a graph means attaching a new node/edge/property. That flexibility is why the entity/relationship/property model beat the table model for evolving domains.

Two ways to build one:

Top-down — experts sit down, model the domain, name entities (purchase orders, customers, reps), name relationships and properties. This is the expert-systems style from the 1980s.
Bottom-up — grow the ontology from real-world signals (customer interactions, tickets). Add entities and relationships as you see them.

Don't reinvent. Reuse existing taxonomies:

schema.org (Google/Microsoft/Yahoo-backed shared vocabulary)
FOAF — Friend of a Friend, for social-network modeling
Dublin Core — early metadata standard for research papers and books
DBpedia — the ontology under Wikipedia; every Wikipedia search hits this graph

What ontologies buy you: inference and constraint

An ontology by itself is data. What makes it useful for agents is the auxiliary technologies — RDFS and OWL — that sit alongside it and let you derive facts and enforce rules.

RDFS: domain and range

If the predicate teaches has domain Teacher and range Student, then the assertion Bob teaches Scooter mechanically infers:

Bob is a Teacher
Scooter is a Student
(via Teacher subClassOf Person) Bob is a Person

OWL: property characteristics

Transitive properties. ancestor is transitive: Sue ancestor Mary + Mary ancestor Ann → Sue ancestor Ann. New facts derived from existing ones.
Functional properties. hasFather is functional (exactly one). So Bob hasFather Jim + BB hasFather Jim implies Bob = BB (same individual, two names).
Disjoint properties. Customer and SupportRep are disjoint — the same entity can't be both. Catches payouts routed to the wrong entity class.

Coyle's point: these constraints and inferences don't sit in the graph. They sit as a reasoner over the graph — the guardrail layer.

The prescription: Pydantic at the door, ontology at the ledger

The load-bearing content of the talk is a validation architecture around the ReAct loop:

while True:
    response = call_llm(prompt, tools)          # LLM formulates a tool call
    if response.stop_reason == "tool_use":
        # Pydantic at the door: type-check the tool call parameters
        params = pydantic_validate(response.tool_input)
        result = execute_tool(params)
        # Ontology at the ledger: validate the result against the domain model
        if ontology_reasoner.validates(result):
            append_to_context(result)
        else:
            # send back to LLM ("this is not working") or escalate to a human
            append_error(result)
    else:
        return response

Two independent validation surfaces:

Pydantic at the door — Python's type-validation library. Types the inputs to tool calls; catches malformed calls before they execute.
Ontology at the ledger — a reasoner over the domain graph. Validates the outputs of tool calls against the domain model; catches semantically-invalid states before they persist.

Corollary: agents should ideally have no side effects. Run the whole loop against the validator before you commit anything to the database.

The specific error classes OWL catches

Coyle's slide of concrete errors that the domain-ontology reasoner catches, and English-only checks miss:

OWL construct	Error class it catches	Example
Functional property	Duplicate of a "must have exactly one"	A second refund posted on the same order
Disjoint classes	Cross-class entity confusion	Payout sent to the support desk instead of the buyer
Value constraints (enumerated)	Made-up values	Status recorded as "probably shipped" when the enum is `{paid, shipped, refunded}`

Each is a class of error where the LLM's probabilistic output looks plausible in natural language but is structurally impossible in the domain.

Loops as Turing completeness (and their failure modes)

Coyle briefly frames agents-with-loops in Böhm-Jacopini 1966 terms: any language that has sequence + conditional + iteration is Turing complete. The loop is the third piece — the reason agentic AI can compute anything computable, and the reason the failure modes are:

Infinite loops — the classic
Loop drift — agents talking to agents, the goal slips
Token cost — every iteration is a cost line

The whole guardrail argument is: symbolic reasoners are how you bound loops that would otherwise drift or burn budget.

The "back to expert systems" framing

Explicit acknowledgment that this is not new: the 1980s expert-systems boom (Japan's Fifth Generation Computer Systems project, US expert-system startups) tried this and hit an AI winter because symbolic systems didn't scale on the hardware of the day. Neural networks re-emerged when Nvidia GPUs made them practical. Now agents-with-symbolic-guardrails is the returning half — the neural half scaled, the symbolic half provides the rails.

Presenter's philosophy note

Coyle opens by quoting Sister Corita Kent (popularized by John Cage): "Nothing is a mistake. There is no win. There's no fail. There's only make." Advocates handwriting notes over typing because "when you're typing your brain is thinking about the letters on the keyboard. When you're writing in a book… all your sensory systems are engaged and you're going to learn faster." Contact via codesupreme.ai (named after Coltrane's A Love Supreme).

Where this connects in the vault

Agentic Loop — Coyle's loop is the ReAct loop with two validation surfaces overlaid; a durable variant to add to that page's "variants worth knowing" list.
Harness (LLM Agents) — the Pydantic-at-the-door + ontology-at-the-ledger prescription is a specific instantiation of harness guardrails, with the twist that the ontology is domain-side enforcement (does this state make sense to the business?) rather than the more common security-side guardrail. Composes with AWARE Framework's guardrail pillar.
Lethal Trifecta — Coyle's "agents should have no side effects until validated" is the vocabulary for mitigating the third vertex of Simon Willison's trifecta (untrusted-input + private-data-access + external-communication). If actions only execute after ontology validation, the trifecta's damage function is bounded.
GraphRAG / Graphiti — both use graph structures, but for retrieval and memory, not action validation. Ontology-as-reasoner is a distinct use of graph structure that the vault hadn't named before this ingest.
Neuro-Symbolic AI — this talk is the vault's first substantive touch on the paradigm as a named research direction (not just background context).

Notes on the talk's evidence and limits

No measurements. The talk is prescriptive, not empirical. There's no benchmark showing that Pydantic+ontology validation catches N% of a class of errors that pure LLM approaches miss. That measurement would raise this page's evidence score.
The Coltrane / handwriting philosophy is charming but presenter-side context, not part of the argument.
Neuro-symbolic AI is a real research direction but often used by graph-database vendors (Neo4j, Ontotext, Stardog) as a marketing frame; the technical content here holds independently of that vendor overlay.
Pydantic is the Python-specific instance; the general pattern is "structural type-check at tool boundaries", which is language-independent.

Sources

Sir59K8ZDPU on YouTube — AI Engineer channel, ~20-min WF 2026 talk
Trigger: ../raw/processed/Daily Learning 2026-08-10 09-51 #3933.md (Telegram capture, openclaw enrichment carried the full transcript)