What this covers
A second refund on the same order. A payout sent to the support desk instead of the buyer. An order status of "probably shipped." These are the kinds of mistakes a probabilistic agent makes and a paragraph of instructions cannot reliably stop. Frank Coyle argues that most agent failures, from brittle tools to fragile handoffs, are symptoms of one missing layer: a formal ontology sitting outside the model as logical guardrails. LLMs reason probabilistically over domains they only half understand, and no amount of prompt engineering closes that gap.
His fix is neurosymbolic: probabilistic reasoning inside, logic outside. An ontology is just typed entities, relationships, and constraints, expressed with old and boring standards like RDFS and OWL, that let you say a payment status must be one of three values, that a customer and a support rep are different things, that an order can only be refunded once. Wrap a Claude tool use loop with a validator: when the model proposes a tool call, check its types with Pydantic and its results against the ontology, and only then let it act. The catches that are painful to write in English become a few lines of logic.
Speaker info: - https://x.com/coyle_frankp - https://www.linkedin.com/in/frank-coyle/ - https://www.frank-coyle.ai/
Timestamps: 0:00 - Intro and an educator's philosophy 2:21 - Two lineages: agents and ontologies 4:04 - Neurosymbolic AI: guardrails around a probabilistic model 5:23 - What an ontology actually is 6:14 - Building one, and the expert systems era 7:55 - Reusing existing taxonomies 9:12 - RDFS and OWL: inference and constraints 12:12 - Agents, loops, and how they break 14:22 - A Claude tool use loop with an ontology validator 17:47 - Pydantic at the door, ontology at the ledger 18:52 - The errors an ontology catches that English cannot
Source description (no synthesized summary yet).
Coyle argues that neuro-symbolic AI—combining probabilistic language models with formal ontologies and symbolic reasoning—provides essential guardrails to keep LLMs aligned with domain logic and prevent hallucinations from causing operational harm.
- LLMs are fundamentally probabilistic and cannot execute actions directly; they need tools and ontological constraints to operate reliably
- Ontologies enable inference and constraint checking (via RDFS and OWL) that catch logical errors LLMs would miss in unstructured text
- Agentic loops require validation layers (type-checking via Pydantic, ontological reasoning) to prevent infinite loops, drift, and costly token accumulation
This asset isn't compiled yet
You're seeing its claims, ranked. Compile it to build the argument threads, weight them, and check each claim against your library — the full view.
The convergence of probabilistic agents and language models with formal symbolic representations (ontologies, rule-based systems, knowledge graphs) is called neuro-symbolic AI, which combines neural networks with symbolic AI to keep LLMs within guardrails.
“what's happening is you're getting the convergence of something that is probabilistic, the agents, the LLMs, with the the more formal representations that you have with ontologies. And so, this term is now being used you hearing this a lot, neuro-symbolic AI. Sounds pretty fancy, but it's really neural networks tied into symbolic AI, which rule-based systems come under that category, um as do the knowledge graphs that we're that we're assembling.”
Ontologies, rooted in Aristotle's philosophy of being and formalized by Quine and Gruber (1993), are fundamentally 'a formal specification of a shared conceptualization'—a tool for representing domain entities, relationships, and properties for systems like graph databases and knowledge graphs.
“It was actually Aristotle who first came up with the concept of we need a philosophy of of being. Like, whoa, kind of heavy. Um but came up with categories of being and this kind of relates to what people are doing now with graph databases and knowledge representation. And there are a couple of other people who kind of formalized it. Uh Von Quine was a philosopher and then this guy Gruber, 1993. And I think this captures what knowledge and uh graph technology really represents. It is a a formal specification of a shared conceptualization.”
RDFS domain and range constraints enable inference: if 'teaches' has domain 'teacher', then observing 'Bob teaches Scooter' logically implies Bob is a teacher; combined with 'all teachers are persons', it also implies Bob is a person.
“if I say teaches has a domain of teacher. That means if I say Bob teaches Scooter in my text, I can infer that Bob is a teacher. 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. What about Scooter? If I say teaches has a range of student, that means the the right side of the verb, then Scooter is a student. And now I have this extra information into my system.”
Existing taxonomies and ontologies such as schema.org, FOAF (Friend of a Friend), Dublin Core, and DBpedia (underlying Wikipedia) represent 15-20 years of standardization work and should be leveraged rather than reinvented when building new ontologies.
“it's helpful to be aware that there are existing taxonomies that people have been working on for the last 15 to 20 years. Things like schema.org, which has a whole set of terms and relationships, so you don't have to reinvent the wheel. In fact, you it's to your advantage to use some of these ontologies. FOAF, Friend of a Friend, for modeling social networks. The Dublin Core, which was an early an early attempt to come up with terms for describing uh research papers and books and so forth.”
LLMs cannot directly execute actions; they can only generate the next word with high probability. However, when given tools and prompts, LLMs can infer tool parameters and invoke them via formatted responses, enabling indirect action execution.
“LLMs can't do anything. All they can do is give us the next word with a high probability. Amazingly, we can now have these conversations it, but they can't do anything. But, we can give it a tool, and we can give it what we want, and say, 'How do you think this tool can help us get what we want?' And then the LLM will set up the parameters, and come back to us, and say, 'Okay, here's my response. I can't execute this tool, but I know what the input parameters are. I know what your context is. I know what your prompt is. So, here is the call that you need to make of the tool, because I can't do it. I'm the LLM. I'm just locked in this box.”
Loops have existed in programming since Bohm and Jacopini's 1966 theorem, which established that three constructs—sequence, conditionals, and loops—are necessary and sufficient for Turing completeness; agents now employ loops to achieve this computational universality.
“Bohm and Jacopini in 1966 came out and said, 'Okay, there is no real difference in programming languages if they have three aspects. Sequence. I can put statement A, statement B, statement C. Fine. I have conditionals. I can have if then. And the last piece, I have a loop. If I have a loop, if I have iteration, if I take these three things, the the language is what's called Turing complete. Can do any can compute anything that a can be computed by computational devices from the work of Alan Turing. Okay? And now we're seeing this in agentic AI. Agents are now have loops.'”
OWL property constraints can enforce that status fields contain only valid enumerated values (e.g., 'paid', 'shipped', or 'refunded'), preventing probabilistic LLMs from generating invalid status values like 'probably shipped'.
“a made-up value like probably shipped. You can specify you must have certain kinds of value. So, uh the status paid, shipped, or refunded, nothing else. And when you're in the pure text world, this can get this can get funky because the the LLMs are again probabilistic and um return some crazy stuff.”
Disjoint properties in OWL can catch errors such as a second refund being issued on the same order by enforcing that certain entity types (like customer and support rep) are mutually exclusive or non-overlapping.
“Look over in the the right-hand column. A second refund on the same order is a is is a problem. But ontologies could catch it, whereas it's it's very tricky to do that in in English. A payout sent to the support desk instead of the buyer. Okay? You can catch that with an owl disjoint property where customer and support rep are two separate entities.”
Agentic AI represents a return to the symbolic AI era, revisiting the expert systems paradigm of the 1980s by combining loops (for Turing completeness) with rule-based reasoning.
“But in a way we are revisiting some of the early stuff with symbolic AI. I would argue we're going back to the world of expert systems. Which is the symbolic part of the whole thing.”
LLM hallucinations are a feature, not a bug, because they reflect the human capacity to imagine and create things that don't yet exist—and this generative capability, when properly channeled, is how large language models produce novel solutions.
“LLMs are by nature probabilistic. People worry about hallucinations, but that's the feature. That's actually a feature of large language models. It's who we are. We hallucinate in a way. We imagine things that may not exist, and then we turn them into reality. And that's what large language models do in in a way.”
Ontological reasoners built on RDFS and OWL can serve as guardrails to keep LLMs 'on track' and 'honest' by validating outputs against domain logic before accepting them.
“really what the point I want to make here is use these re- you can have a reasoner built on ontology to check keep the LLM on track, have guardrails to keep it honest. Okay? And for the guardrails, I'm referring to these concepts re- these support technologies with RDFS and owl.”
Derivations and constraints defined in RDFS and OWL sit alongside the core graph rather than within it, and can be applied to help agents operate reliably when dealing with probabilistic language model outputs.
“these derivations and constraints that don't sit in the graph, they sit sort of on the side and they can help as we're going to see, I'm going to propose, when we deal with agents, how they can they can help us out.”
Ontologies should be integrated into agent loops as validators after tool execution: tool results are formatted according to the ontology, and a reasoner checks whether the response is valid before accepting or rejecting it.
“I have this stuff in red here. This is where I think the LLMs and other uh I'm sorry, not LLMs. The ontologies and stuff can come in. So, if you look down there, after the the tool is called, it said tool runs. This is where ontologies could come in. The tool's going to give us information. We put the information in a form that our our our our validator can use, and think about the validator as operating with this these ontologies about our domain, then we can make some sense of whether the response of the LLM is reasonable.”
Agent loops should include validation feedback: if tool execution produces an unreasonable result (by ontological standards), the agent should either request correction from the LLM or escalate to human review rather than proceeding.
“So, this is the loop. Call a tool, check the stop reason. If it's a reasonable result, then let's go with it. If it's not reasonable, go back to the LLM. Say, 'Oh, this is this is not working.' Or get a human in the loop. But the idea is to surround the input with checks.”
Agent validation should employ layered checks: Pydantic at the input layer (type correctness), ontology validation at the output layer (logical consistency), with agents having no side effects until validation passes.
“So, you want to check your types with Pydantic and then check your results with the ontology. So, Pydantic at the door, ontology at the ledger, and pure agents and by the way, your agents should try to have no side effects. That helps the whole logic. Meaning, they're not running off doing something that they're they're changing they're changing things in the database not yet. You want to run them through the ontology first and make sure that works.”
Agent loops carry three critical risks: they can enter infinite loops (a programming hazard), drift as agents coordinate and go off-course, and accumulate token costs as the loop continues executing.
“The danger though of loops is that they can break. If you're If you're a programmer, you know, you've all go into infinite loop. Not good. Loops can drift as agents start talking to each other, things get all go off off the rails. And loops can cost you money. Token counts crank up as the loops continue.”
Symbolic AI and expert systems of the 1980s, including Japan's Fifth Generation Computer Project, were ultimately unsuccessful because they could not scale, leading to an 'AI winter' until neural networks became feasible through GPU acceleration in the 2000s.
“expert systems was the way to do AI. Symbolic AI was the way to go. Companies rose, millions of dollars were spent. Uh the the Japanese created this uh future world project in the late '80s. People in America were my my son was taking Japanese in school because of these expert systems. And but they couldn't scale. They couldn't scale, and then we went into a kind of AI winter.”
There are two primary approaches to building ontologies: top-down (experts analyze the domain and define entities, properties, and relationships upfront) and bottom-up (entities and relationships are added iteratively from observed customer interactions and domain behavior).
“There are a couple of ways you can approach it. You can have a top-down approach or a bottom-up approach. Top-down approach is you get the experts together and they sit down and analyze the domain, come up with the entities. What do we have? We have purchase orders, we have customers, we have customer representatives, and we're going to structure them. They have properties. These are the relationships. Okay, that's one way.”
The concept of agents—entities that perceive, decide, and act—evolved from early AI pioneers like John McCarthy, Selfridge, and Marvin Minsky's Society of Mind framework, building toward the formal definition of artificial intelligence established in 1956.
“agents, when did we start talking about agents? Well, goes goes back to the early initial days of AI. People like John McCarthy, uh uh uh uh uh Selfridge, Marvin Minsky, Society of Mind. People started thinking about the fact that this new computing technology was going to lead us into some kind of artificial intelligence, which is a term that came in 1956 when all these characters got together and tried to figure out where the future was going. Okay? And the concept of an agent finally evolved, things that perceive and decide and then act”
Functional properties in OWL (like 'has father') constrain relationships to a single value: only one father can exist, and if Bob and BB are both identified as Jim's father, the system infers Bob and BB are the same individual.
“there's some properties called functional properties, which means only one. So, has father is a functional property. You can only have one father. You can only have one mother. That is a functional property. Okay? So, that's that can serve as a constraint. So, when if you say Bob is my Bob is Jim's father, BB is Jim's father, well, the inference here is that Bob and BB are two ways of representing the same individual because that is a functional property. Can only have one.”
Transitive properties in OWL (like ancestry) enable automatic inference: if Sue is an ancestor of Mary and Mary is an ancestor of Ann, the system can infer Sue is an ancestor of Ann without explicit statement.
“transitive property transitive property says, if Sue is an ancestor like ancestor is a transitive property. If Sue is an ancestor of Mary and Mary is an ancestor of Ann, then Sue is an ancestor of Ann. Okay? This was not initially into my graph system, but with applying these functional properties, I can then add and augment the system with this extra data.”
Writing by hand (pen and pencil) engages all sensory systems and promotes faster learning compared to typing, because typing directs cognitive resources to keyboard mechanics rather than conceptual synthesis.
“Get a notebook. Get a pen, a pencil. Draw pictures, write stuff down. Just don't type because when you type you when you're typing your brain is thinking about the letters on the keyboard. 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.”
Coyle's educational philosophy, inspired by Sister Corita Kent and John Cage, emphasizes 'Nothing is a mistake. There is no win. There's no fail. There's only make'—prioritizing hands-on creation and experimentation over passive reading.
“Nothing is a mistake. There is no win. There's no fail. There's only make. And more and more today, that's what's important. Get down and make stuff, and that's how you're going to learn, not by necessarily reading.”
Ontologies are fundamentally a representation of entities, their relationships to other entities, and the properties of those entities—a structure that evolved from the limitations of relational databases, which require restructuring to add new columns or information.
“ontologies are. It's not They're not complicated. They're basically a representation of entities and their relationships to other entities. And these entities have properties. And this whole concept of graph databases arose when people began to realize that relational databases sticking data into tables was too restrictive. You wanted to add something new to a relational database, so you have to add a new column. Man, I had then then you have to redo the whole structure. With a with a graph database, you can just attach another item. You can just attach a property. You can attach a relationship.”
Auxiliary ontological technologies like RDFS and OWL sit alongside graph structures and enable inference and constraint checking by formalizing rules about domain relationships.
“there are other augmenting technologies, auxiliary technologies. Things that we call the things like RDFS, which is a technology, and OWL, which I'll talk more about. So, these have these kind of sit over to the side of your graph. So, I'm not going to talk about on I mean ontology is a big word and it's often confusing and used in many ways, but think of it as a graph data structure. Okay? And you have the entities and relationships, but you want to apply some control over them. Or you want to be able to make inference over them.”
Computer science degrees, which used to guarantee jobs, no longer do so due to AI disrupting the field, though 5,000 people attending this event suggests AI and agents remain high-demand areas.
“Degree was a guaranteed job, and now thanks to AI, it's not. But then again, 5,000 people are here. So, AI and and agents are um seem to be the way to go.”
In agent loops, the 'stop reason' signal indicates why the LLM halted: if stop_reason is 'tool_use', the agent should execute the tool specified by the LLM's parameters; otherwise (e.g., natural completion), the response is final.
“stop reason means the LLM has stopped for some reason. The The reason here is that it can't do anything, and if the reason is tool use, ah, now it's time. Let's go execute that tool. So, that second line, get tool. It takes the response, which is formulating the the parameters, and triggering the action.”
Pydantic is a Python library that adds type specifications to an otherwise untyped language, allowing agents to check input/output parameter types before tool execution.
“something called Pydantic. Pydantic is a way to specify the types of what you want the types of the parameters to be. Those of you who who do know Python, know Python is a unstructured type language. So, you can have a variable x = 20, x = hello, no problem. There's no typing. Pydantic adds typing to that.”