Why Agentic Systems Need Ontologies — Frank Coyle, UC Berkeley

A computer science degree no longer guarantees employment, and the speaker attributes the change to AI.

“Degree was a guaranteed job, and now thanks to AI, it's not.”

assertion · guest

contested · medium confidence — The 2024-2025 slump in junior CS hiring is real and widely reported, but labor economists and tech-industry analysts also attribute it to post-pandemic overhiring corrections, interest-rate-driven cuts, and an oversupply of CS grads, not AI alone. Attribution to AI specifically is a live debate, not a settled fact.

To check: New-grad CS unemployment/underemployment data (e.g., Fed/BLS underemployment rate for recent CS majors) and hiring-freeze causes cited by major tech employers 2023-2026.

The speaker cites 5,000 attendees at the event as evidence that AI and agents are where the opportunity now lies.

“5,000 people are here. So, AI and and”

quantity · guest

unverifiable · low confidence — An attendance figure at a specific event he is addressing; I have no independent way to confirm it and it's presented as a firsthand observation, not a researched fact.

To check: Official attendance figures from the event organizer.

Typing diverts cognitive attention to keyboard mechanics rather than content.

“Just don't type because when you type you when you're typing your brain is thinking about the letters on the keyboard.”

assertion · guest

contested · medium confidence — Handwriting-vs-typing research (e.g., Mueller & Oppenheimer 2014) does find differences in learning outcomes, but the standard explanation is that typing enables fast verbatim transcription that bypasses paraphrasing/processing, not that attention is diverted to 'letters on the keyboard.' The mechanism as stated is a folk simplification of a real but more nuanced finding.

To check: Mueller & Oppenheimer 'The Pen Is Mightier Than the Keyboard' (2014) and follow-up replications on note-taking modality and learning.

Handwriting engages more sensory systems than typing and therefore produces faster learning.

“When you're writing in a book, your whole brain, your your whole all your all your sensory systems are engaged and you're going to learn faster that way.”

assertion · guest

contested · medium confidence — The literature this echoes generally reports better conceptual retention/comprehension for handwritten notes, not faster learning; handwriting is in fact slower than typing. The 'whole brain, all sensory systems' framing is evocative but not the specific mechanism studies identify.

To check: Same handwriting-vs-typing literature; look for any study measuring learning speed (not just retention quality) by note modality.

The term 'artificial intelligence' dates from a 1956 gathering of early AI researchers.

“which is a term that came in 1956 when all these characters got together and tried to figure out where the future was going.”

quantity · guest

consistent · high confidence — The term 'artificial intelligence' was coined by John McCarthy for the 1956 Dartmouth Summer Research Project, attended by McCarthy, Minsky, Shannon, Selfridge and others. This matches standard AI history.

To check: Dartmouth Summer Research Project on Artificial Intelligence, 1956, proposal and attendee list.

An agent is defined as something that perceives, decides and acts — the definition now realised in today's systems.

“the concept of an agent finally evolved, things that perceive and decide and then act and that's what we're seeing now.”

assertion · guest

consistent · high confidence — This matches the canonical 'agent' definition in AI textbooks (Russell & Norvig: an agent perceives its environment via sensors and acts via actuators, with decision-making in between).

To check: Russell & Norvig, 'Artificial Intelligence: A Modern Approach', Chapter 2 on intelligent agents.

Ontology as a field originates with Aristotle's philosophy of being, not with modern computing.

“It was actually Aristotle who first came up with the concept of we need a philosophy of of being.”

assertion · guest

consistent · high confidence — Aristotle's Categories and Metaphysics are standard reference points in philosophy for the origin of ontology as a study of being and categories; this lineage to modern computational ontology (via Quine, then Gruber) is a commonly taught history in knowledge-representation courses.

To check: Aristotle's Categories; standard KR textbooks tracing 'ontology' etymology and philosophical origin.

An ontology is Gruber's 'formal specification of a shared conceptualization', and that is what knowledge-graph technology represents.

“is a a formal specification of a shared conceptualization”

assertion · guest

consistent · high confidence — This closely matches Gruber's widely cited 1993 definition ('an ontology is an explicit specification of a conceptualization'), later refined by Studer, Benjamins & Fensel (1998) to add 'formal' and 'shared.' The speaker is blending the two canonical versions, which is standard practice in the field.

To check: Gruber, 'A Translation Approach to Portable Ontology Specifications' (1993); Studer et al. (1998) refinement.

Neuro-symbolic AI constrains probabilistic LLMs by pairing them with formal symbolic structures.

“sort of represents a way to keep the LLM on its guardrails, because LLMs are by nature probabilistic.”

assertion · guest

plausible · medium confidence — Neuro-symbolic AI as a means of constraining probabilistic generative models with formal/symbolic structure is an active, real research and engineering direction (e.g., constrained decoding, knowledge-graph grounding, guardrail frameworks), but the speaker frames it explicitly as his own argument rather than settled consensus.

To check: Survey literature on neuro-symbolic AI (e.g., Garcez & Lamb) and industry guardrail frameworks (Guardrails AI, NeMo Guardrails) that pair LLMs with symbolic validation.

Hallucination is not a defect of LLMs but an intrinsic feature of how they work.

“People worry about hallucinations, but that's the feature. That's actually a feature of large language models.”

contrarian · guest

contested · medium confidence — Some researchers and commentators frame confabulation as an inherent, even useful, byproduct of generative sampling (creativity, brainstorming), but the mainstream engineering and safety view treats hallucination as a reliability defect actively being mitigated (RAG, fact-checking layers, RLHF). Both camps exist; this is not settled.

To check: OpenAI/Anthropic/DeepMind technical reports on hallucination mitigation vs. commentary treating confabulation as a feature (e.g., discussions of LLMs as 'dreaming machines').

Graph databases arose because relational tables proved too rigid for evolving data.

“people began to realize that relational databases sticking data into tables was too restrictive”

assertion · guest

plausible · medium confidence — This captures a real and commonly cited driver of the graph-database/NoSQL movement, but it is one factor among several (horizontal scalability needs, semi-structured/schema-less web data, performance on relationship-heavy queries) that historians of the NoSQL movement usually list together.

To check: History of NoSQL and graph databases (e.g., Neo4j's early motivation papers, RDF/Linked Data literature from the mid-2000s).

Adding new information to a relational database requires a new column and a restructuring of the schema.

“add a new column. Man, I had then then you have to redo the whole structure.”

assertion · guest

contested · medium confidence — Modern relational databases support ALTER TABLE ADD COLUMN without rebuilding the whole schema in most cases; the pain point is real at scale (locking, migrations, downstream code) but 'redo the whole structure' overstates the mechanical difficulty for a general audience.

To check: SQL ALTER TABLE semantics in major RDBMS (PostgreSQL, MySQL, SQL Server) and documented migration costs at scale.

Graph databases let you extend a model by attaching items, properties or relationships without restructuring.

“With a with a graph database, you can just attach another item. You can just attach a property. You can attach a relationship.”

assertion · guest

consistent · high confidence — Schema flexibility (adding nodes, properties, edges without a global schema migration) is a genuine and well-documented advantage of graph/RDF data models over rigid relational schemas.

To check: RDF/graph database documentation (e.g., Neo4j, RDF triple stores) on schema-less or schema-flexible data modeling.

Expert systems failed because they could not scale, which precipitated the AI winter.

“They couldn't scale, and then we went into a kind of AI winter.”

assertion · guest

plausible · medium confidence — Scaling and knowledge-acquisition bottlenecks are standard explanations for the collapse of 1980s expert systems and the subsequent AI winter, alongside brittleness and high maintenance cost; the claim is broadly accurate but compresses a multi-causal history into one factor.

To check: Historical accounts of the late-1980s AI winter, including the collapse of the Lisp machine and expert-systems markets and Japan's Fifth Generation Computer project.

Neural networks existed in the 1960s but could not scale until GPUs, built for video games, became available.

“Neural networks were put out there in the '60s, but they couldn't scale because we didn't happen to have Nvidia”

assertion · guest

plausible · medium confidence — The broad arc (1960s perceptrons stalled after Minsky-Papert critique, revival with 1980s backpropagation, explosive scaling once GPUs enabled deep learning circa 2006-2012) is standard AI history, but this retelling compresses the intervening decades and skips the 1980s backprop revival, making the GPU-as-sole-unlock framing a simplification.

To check: History of deep learning scaling, e.g., AlexNet (2012) on GPUs, and the 1969 Minsky-Papert 'Perceptrons' critique and 1986 backpropagation revival.

Reusable public taxonomies have been under development for 15 to 20 years.

“taxonomies that people have been working on for the last 15 to 20 years”

quantity · guest

contested · medium confidence — Schema.org launched in 2011 (~15 years before 2026, fitting the claim), but FOAF (~2000) and Dublin Core (~1995) are 25-30 years old, so the stated 15-20 year window undercounts the age of the other examples he cites in the same breath.

To check: Founding/publication dates: schema.org (2011), FOAF (2000), Dublin Core Metadata Initiative (1995).

Builders should reuse existing published ontologies rather than authoring their own from scratch.

“it's to your advantage to use some of these ontologies”

assertion · guest

consistent · high confidence — Reusing established vocabularies (schema.org, FOAF, Dublin Core) instead of building bespoke ontologies from scratch is standard, widely-taught best practice in knowledge engineering and Linked Data work.

To check: W3C and Linked Data best-practice guides on ontology reuse.

Wikipedia search is claimed to run over the DBpedia graph database.

“Wikipedia is based on an ontology called DBpedia. So, when you do a search on Wikipedia, it's looking things up in its giant graph database.”

assertion · guest

inaccurate · high confidence — This reverses the actual relationship: DBpedia is a community project (Auer, Bizer et al., ~2007) that extracts structured RDF data FROM Wikipedia's infoboxes; Wikipedia itself does not run on or search over DBpedia, and its native search uses Elasticsearch/CirrusSearch, not a DBpedia graph store.

To check: DBpedia project documentation and papers describing it as an extraction from Wikipedia; Wikipedia's own search architecture documentation (MediaWiki/CirrusSearch).

RDFS domain declarations let a system infer an entity's type from the predicate used about it.

“has a domain of teacher. That means if I say Bob teaches Scooter in my text, I can infer that Bob is a teacher.”

assertion · guest

consistent · high confidence — This is a textbook-correct description of RDFS domain semantics: rdfs:domain on a property entails the subject is a member of the specified class.

To check: W3C RDF Schema (RDFS) specification, section on rdfs:domain.

Chaining a subclass axiom onto a domain inference yields a further type inference.

“And if I say all teachers are persons, then this statement lets me know if I say Bob teaches Scooter, now I know Bob is a person, Bob is a teacher.”

assertion · guest

consistent · high confidence — Correctly chains an rdfs:subClassOf axiom onto a domain-based inference, exactly as RDFS entailment rules specify.

To check: RDFS entailment rules combining subClassOf and domain inference (W3C RDF Semantics spec).

RDFS range declarations type the object of a relation.

“If I say teaches has a range of student, that means the the right side of the verb, then Scooter is a student.”

assertion · guest

consistent · high confidence — Correct description of rdfs:range semantics, typing the object position of a triple.

To check: W3C RDF Schema (RDFS) specification, section on rdfs:range.

OWL transitive properties derive new facts that were never asserted in the graph.

“If Sue is an ancestor of Mary and Mary is an ancestor of Ann, then Sue is an ancestor of Ann.”

assertion · guest

consistent · high confidence — Textbook-correct illustration of an OWL transitive property (owl:TransitiveProperty), a standard example used in every OWL tutorial.

To check: OWL 2 Web Ontology Language specification, TransitiveProperty axiom.

Functional properties in OWL express a one-value-only constraint, such as having a single father.

“has father is a functional property. You can only have one father. You can only have one mother.”

assertion · guest

consistent · high confidence — Correctly describes owl:FunctionalProperty semantics (at most one value per subject); the 'one father/one mother' example is a standard pedagogical illustration.

To check: OWL 2 specification, FunctionalProperty definition.

Because 'has father' is functional, two differently named fathers of the same person must be identified as one individual.

“the inference here is that Bob and BB are two ways of representing the same individual because that is a functional property.”

assertion · guest

consistent · high confidence — Correct entailment: if a functional property has two distinct asserted values for the same subject, an OWL reasoner infers owl:sameAs between those values. This is a genuine and commonly used OWL reasoning pattern for entity resolution.

To check: OWL 2 direct semantics on FunctionalProperty entailing sameAs when two fillers are asserted.

Böhm and Jacopini's 1966 result holds that languages with sequence, conditionals and iteration are equivalent in power.

“Bohm and Jacopini in 1966 came out and said, "Okay, there is no real difference in programming languages if they have three aspects.”

quantity · guest

consistent · high confidence — The Böhm–Jacopini theorem (1966) is a real and correctly dated result in structured-programming theory, showing any flowchart-computable function can be expressed with sequence, selection, and iteration.

To check: Böhm, C. and Jacopini, G., 'Flow diagrams, turing machines and languages with only two formation rules,' Communications of the ACM, 1966.

Sequence, conditionals and iteration together make a language Turing complete.

“If I have a loop, if I have iteration, if I take these three things, the the language is what's called Turing complete.”

assertion · guest

contested · medium confidence — This is a common but technically imprecise popularization. Böhm–Jacopini's theorem is about equivalence to flowcharts, not Turing completeness per se; formal Turing completeness also requires unbounded memory/storage, not just the three control constructs. Theoretical computer scientists would flag the missing memory condition even though the informal point (sequence+conditional+loop is the standard trio for general-purpose computation) is widely repeated in programming pedagogy.

To check: Formal definition of Turing completeness (requires unbounded memory plus conditional branching and iteration/recursion) vs. the narrower scope of the Böhm–Jacopini structured-programming theorem.

Because agents now contain loops, agentic AI has the last ingredient needed for full computational generality.

“Agents are now have loops. Loops give us the last piece in the equation of giving us a technology that is capable of doing anything that computational devices can do.”

assertion · guest

inaccurate · medium confidence · novel — This conflates the Turing-completeness of the underlying programming substrate (e.g., Python, already Turing complete) with the addition of an orchestration loop at the agent level. Adding a while-loop around an LLM call doesn't newly confer computational universality — that property already belonged to the host language before agents existed. It's a novel rhetorical synthesis but a category error as stated.

To check: Whether Python (or whichever language hosts the agent loop) was already Turing complete prior to any agent framework — trivially yes, since general-purpose languages have long satisfied the sequence/conditional/iteration + unbounded memory criteria.

Agent loops carry the failure mode of breaking, e.g. running infinitely.

“The danger though of loops is that they can break.”

assertion · guest

consistent · high confidence — Uncontroversial: infinite loops, runaway iteration and non-terminating processes are a basic, well-known failure mode in any looping construct, agentic or not.

To check: Any programming textbook's treatment of infinite loops and termination conditions.

Multi-agent interaction causes loops to drift off course.

“Loops can drift as agents start talking to each other, things get all go off off the rails.”

assertion · guest

plausible · low confidence — Compounding-error/context-drift failure modes in multi-agent systems are widely reported anecdotally in agent-engineering discourse (e.g., agents reinforcing each other's errors in long conversations), but no mechanism or example is given here, so it stands as an assertion rather than demonstrated evidence.

To check: Case studies or benchmarks of multi-agent conversational drift, e.g., reports from AutoGPT/multi-agent frameworks documenting compounding error over long loops.

Longer-running agent loops raise token consumption and therefore cost.

“loops can cost you money. Token counts crank up as the loops continue.”

assertion · guest

consistent · high confidence — Straightforward and well-documented fact of LLM API economics: each loop iteration re-sends growing context and adds new completions, both billed per token.

To check: Any LLM API pricing documentation (OpenAI, Anthropic) showing token-based billing and how iterative/agentic loops increase cumulative token usage.

The speaker argues, hedged, that agentic AI is a return to the symbolic expert-systems paradigm.

“I would argue we're going back to the world of expert systems.”

assertion · guest

contested · medium confidence — This is an explicitly hedged, argued framing. Some in the field draw exactly this parallel (symbolic rule systems reappearing as guardrails/knowledge graphs around LLMs), while others argue the analogy is superficial since LLMs are statistically learned rather than hand-encoded rule bases, making the underlying mechanisms fundamentally different from 1980s expert systems.

To check: Comparative discussions of neuro-symbolic AI vs. classical expert systems in recent AI commentary and papers on 'symbolic AI's return.'

LLMs cannot act; they only predict the next token, which is why tools and harnesses are needed.

“LLMs can't do anything. All they can do is give us the next word with a high probability.”

assertion · guest

consistent · high confidence — Accurate description of the base mechanism of autoregressive transformer LLMs (next-token prediction); the agency in 'agents' comes from the surrounding harness/tool-execution loop, not the model itself, which is a standard and correct technical framing.

To check: Transformer/autoregressive LLM architecture papers describing next-token prediction as the core generative mechanism.

Python is untyped, permitting a variable to hold values of any type.

“know Python is a unstructured type language. So, you can have a variable x = 20, x = hello, no problem. There's no typing.”

assertion · guest

consistent · medium confidence — The behavioral example is correct — Python is dynamically typed, so a variable can be rebound to values of different types without error. 'Unstructured type language' is nonstandard terminology (the field usually says 'dynamically typed' or notes Python is strongly, dynamically typed), but the described behavior is accurate.

To check: Python language reference on dynamic typing and variable binding.

Agent outputs should be validated in two stages: Pydantic for parameter types, ontology for result plausibility.

“check your types with Pydantic and then check your results with the ontology.”

assertion · guest

plausible · medium confidence — This matches a real and growing pattern in LLM agent engineering: Pydantic (or similar schema validators) is widely used to enforce structured output from LLM tool calls, and pairing that with a downstream semantic/business-rule validator is a sensible, increasingly discussed design, though the specific ontology-based second stage is more his own proposal than an established industry standard.

To check: Adoption of Pydantic-based structured output validation in agent frameworks (e.g., Instructor, LangChain output parsers) and any published case studies pairing it with ontology/SHACL validation.

Agents should avoid side effects such as writing to the database before ontology validation.

“your agents should try to have no side effects.”

assertion · guest

consistent · high confidence — This mirrors a well-established software-engineering principle (validate before committing state changes, prefer idempotent/staged operations), now commonly re-applied to agent design to prevent premature database writes from unchecked LLM output.

To check: General software engineering practice around idempotency and 'validate-then-commit' patterns, now discussed specifically in agent-safety literature.

An error like a second refund on the same order is catchable by ontology constraints but hard to catch in natural language.

“But ontologies could catch it, whereas it's it's very tricky to do that in in English.”

assertion · guest

contested · medium confidence — Whether OWL-style ontologies are actually well suited to catching this kind of negative constraint ('no second refund on the same order') is debatable: OWL's open-world assumption makes it awkward for closed-world 'this must not exist' checks, which is precisely why SHACL and other closed-world validation languages were developed for RDF data. Practitioners in the Semantic Web community differ on whether OWL reasoning or SHACL-style constraint validation is the right tool for this kind of business-rule enforcement.

To check: W3C SHACL specification and its stated motivation (closed-world constraint validation) versus OWL's open-world semantics; discussions of OWL's limitations for integrity-constraint checking.

OWL disjointness catches a payout routed to a support rep instead of the buyer.

“You can catch that with an owl disjoint property where customer and support rep are two separate entities.”

assertion · guest

plausible · low confidence — owl:disjointWith can indeed flag a logical inconsistency if an individual is asserted to be both a Customer and a SupportRep, but the mechanism connecting that class-level inconsistency to catching a specific 'misdirected payout' event is not spelled out, leaving a gap between the OWL construct and the described real-world failure it's meant to catch.

To check: Worked implementation showing an OWL disjoint-classes axiom actually flagging a misrouted-payment scenario in an agent pipeline, e.g., a published case study or code example.

Because LLMs are probabilistic they can return invalid values such as made-up statuses.

“because the the LLMs are again probabilistic and”

assertion · guest

consistent · high confidence — Uncontroversial and well-documented: probabilistic generation means LLMs can produce out-of-schema or invented values (e.g., a nonexistent status like 'probably shipped') absent constrained decoding or validation.

To check: Documented cases of LLM structured-output failures producing invalid enum/status values in production systems.

An ontology-backed reasoner should be used as a guardrail on LLM output.

“reasoner built on ontology to check keep the LLM on track, have guardrails to keep it honest.”

assertion · guest

plausible · medium confidence — This is the talk's central thesis, restated as a conclusion: pairing an LLM agent with a symbolic reasoner/validator to enforce constraints is a real and increasingly discussed engineering pattern (neuro-symbolic guardrails), but as a general prescription it remains a design recommendation and architectural bet rather than a demonstrated, benchmarked solution in this talk.

To check: Published neuro-symbolic guardrail systems (e.g., combining LLM agents with OWL/SHACL reasoners) and any benchmark showing reduced error rates versus ungated LLM tool use.