Agentic systems combine probabilistic language models with symbolic ontologies that constrain what the model can propose and do.
2
Ontologies describe typed entities, relationships, properties, and rules, then use RDFS and OWL to infer facts and reject invalid states.
3
A practical agent loop can check tool parameters with Pydantic, validate tool results against an ontology, and send invalid results back to the model or a human.
Summary
Frank Coyle argues that agent failures often come from giving a probabilistic model too much freedom over a domain it only partly understands. Prompts written in English cannot reliably prevent a second refund, an invalid payout recipient, or a status such as "probably shipped." His proposed architecture is neurosymbolic: use the language model for probabilistic reasoning, then place formal logic around it. An ontology defines the domain's entities, relationships, properties, and constraints. RDFS can support inferences from domains and ranges, while OWL can express rules such as transitivity, functional properties, and disjoint entities. In a Claude tool-use loop, Pydantic checks input types before execution, and the ontology checks the tool's results before they affect the system. Coyle is also honest about the risks of agent loops, including infinite repetition, drift between agents, and rising token costs. The approach brings some expert-system ideas back into current agent design.
Agents and ontologies come from different intellectual lineages
Coyle traces agents to early artificial intelligence, including John McCarthy, Marvin Minsky, and the idea of systems that perceive, decide, and act. Ontologies have an older philosophical lineage that reaches back to Aristotle's categories of being. He cites Tom Gruber's 1993 definition of an ontology as "a formal specification of a shared conceptualization." For an agent system, that shared conceptualization describes the organization's domain. It tells the system what kinds of things exist and how they relate. Coyle presents the current opportunity as a meeting between probabilistic agents and formal knowledge representation.
Neurosymbolic design puts logic around the language model
Coyle describes neurosymbolic AI as neural networks connected to symbolic systems, including rule-based systems and knowledge graphs. The language model remains probabilistic, and he treats hallucination as part of how such models work rather than as an issue that prompts can fully remove. The symbolic layer provides guardrails. It can constrain the model's outputs using domain rules and structured knowledge. This division lets the LLM suggest a course of action while another system checks whether that action fits the domain. The model does not need to carry every business rule in a prompt.
An ontology is a graph of typed entities and relationships
Coyle defines an ontology in practical terms: entities, their relationships to other entities, and their properties. He connects this model to graph databases, where a new property or relationship can be attached without redesigning a table schema. A business ontology might include purchase orders, customers, and customer representatives, along with their properties and relationships. Teams can build one from the top down by asking domain experts to define the concepts, or from the bottom up by adding entities and relationships found in customer activity. The goal is a formal description of what the organization does.
Teams do not always need to define every term themselves. Coyle names schema.org as a collection of terms and relationships, FOAF for social networks, and Dublin Core for describing research papers and books. He also says Wikipedia is based on DBpedia and uses a large graph for searches. These existing resources can supply concepts that a new ontology can reuse. Coyle's point is practical: look for established vocabularies before creating a domain model from scratch. Reuse can reduce the work needed to describe common entities and relationships.
RDFS and OWL add inference and constraints to the graph
Coyle explains that RDFS and OWL sit alongside the graph and give it rules. With RDFS domains and ranges, a statement that Bob teaches Scooter can imply that Bob is a teacher and a person, while Scooter is a student. OWL can describe transitive properties, such as ancestry, so that if Sue is an ancestor of Mary and Mary is an ancestor of Ann, Sue is an ancestor of Ann. Functional properties express limits such as having one father. If two names are given as someone's father, the system can infer that they refer to the same individual. These rules add facts and reject incompatible states.
Coyle connects current agent loops to the sequence, conditional, and iteration structures described by Bohm and Jacopini in 1966. Loops give agents the ability to continue acting, but they also introduce familiar programming problems. An agent can enter an infinite loop, drift as agents communicate with one another, or keep consuming tokens and increasing cost. Coyle sees this as a return to some expert-system concerns, with symbolic logic providing control around a more flexible probabilistic model. The loop needs checks so that continued execution depends on whether each result is reasonable.
Tool results should pass through an ontology before causing effects
Coyle walks through a Claude agent loop with a model, a prompt, and a tool. The LLM cannot execute the tool itself, so it produces the input parameters and a tool-use stop reason. The surrounding program then calls the tool and receives information. Coyle places the ontology validator after that tool call. The validator represents the result in a form it can inspect and checks whether the result makes sense in the domain. If it is reasonable, the loop continues. If it is invalid, the system can return to the LLM with the problem or involve a human. He recommends surrounding agent input and output with checks.
Pydantic checks the types while the ontology checks the business state
Coyle recommends using Pydantic to specify and validate tool parameter types because Python does not enforce types by default. The ontology then checks the results against the domain's rules. His shorthand is "Pydantic at the door, ontology at the ledger." He also recommends that agents have no side effects while they are being checked. An agent should not change the database before the proposed action has passed the ontology's validation. This separates basic parameter validation from the deeper question of whether an action is allowed by the organization's model.
Formal constraints catch errors that English instructions struggle to express
Coyle gives concrete examples of errors an ontology can reject. A second refund on the same order violates a constraint. A payout sent to a support representative instead of the buyer conflicts with a rule that customers and support representatives are disjoint entities. An order status of "probably shipped" violates an allowed-value constraint if status must be paid, shipped, or refunded. These rules are difficult to express and enforce reliably in ordinary prose because the LLM handles text probabilistically. RDFS and OWL let a reasoner check the proposed state before the agent acts.
"A second refund on the same order is a problem. But ontologies could catch it, whereas it's very tricky to do that in English."19:18
Who should watch
You are building agents that can call business tools and need to prevent invalid actions from reaching a database or payment system.
Your prompts contain domain rules such as allowed statuses, unique relationships, or valid recipients, and you need those rules checked as logic rather than prose.
You are deciding how to combine LLM flexibility with typed inputs, knowledge graphs, validators, and human review.
