Agent Systems and Ontologies: The Convergence of Probabilistic and Symbolic AI

There is a peculiar moment happening in artificial intelligence. On one side, we have large language models that can generate prose, code, and reasoning chains with uncanny fluency. On the other, we have the sobering reality that these same systems confidently hallucinate, contradict themselves, and lack any principled way to verify their outputs against established knowledge.

The question is not whether LLMs are useful. They clearly are. The question is how we deploy them in contexts where correctness matters—where issuing a second refund on the same order, or sending a payout to the support desk instead of the customer, has real business consequences.

Frank Coyle, who teaches at UC Berkeley and has been in computing for three decades, recently gave a talk that cuts through the noise. His argument is straightforward: the future of AI is not just bigger models. It is the disciplined marriage of probabilistic agents with formal ontologies that provide guardrails, reasoning, and accountability. This convergence—what researchers call neuro-symbolic AI—is where the field is heading, and it has immediate implications for how we architect intelligent systems.

Two Lineages Converging

To understand where we are going, it helps to see where we have been. The concept of an "agent"—something that perceives, decides, and acts—traces back to the earliest days of AI. John McCarthy, Marvin Minsky with his Society of Mind, and others at the 1956 Dartmouth workshop were already thinking about how computing could lead to artificial intelligence [1].

Ontologies, meanwhile, have an even older pedigree. Aristotle proposed the first philosophy of being—categories of existence that underlie everything we can talk about. In computing, the modern definition comes from Tom Gruber's 1993 paper: an ontology is "a formal specification of a shared conceptualization" [2]. This is not merely academic. It is the foundation of graph databases, knowledge representation, and the semantic web.

What is happening now is the convergence of these two lineages. Probabilistic systems (neural networks, LLMs) are being integrated with symbolic systems (rule-based reasoning, knowledge graphs, ontologies). Marcus argues convincingly that robust AI requires this integration—deep learning alone is insufficient for systems that must reason about causality, structure, and abstraction [3].

"Neuro-symbolic AI represents a way to keep the LLM on its guardrails."

— Frank Coyle, UC Berkeley

What Ontologies Actually Are

An ontology, stripped of its philosophical weight, is a representation of entities and their relationships. Entities have properties. Relationships connect entities to other entities. This structure is what makes graph databases so flexible compared to relational tables: you can attach new properties or relationships without redesigning the entire schema.

There are two practical approaches to building ontologies:

Top-down: Domain experts analyse the field, identify key entities (customers, orders, products), define their properties, and specify relationships. This mirrors the expert systems approach of the 1980s—ambitious, intellectually coherent, and historically prone to failure because such systems could not scale beyond narrow domains.

Bottom-up: Extract structure from existing data—customer interactions, documents, transaction logs—and incrementally build the ontology. This is more pragmatic but requires tools to identify patterns and validate consistency.

The good news is that you rarely need to start from scratch. Established taxonomies already exist: schema.org for general web entities, FOAF for social networks, Dublin Core for bibliographic metadata, and DBpedia (the structured ontology underlying Wikipedia). These provide battle-tested foundations that have been refined over decades.

RDFS and OWL: Reasoning on Graphs

Having entities and relationships is useful. Being able to reason about them is transformative. This is where RDFS (RDF Schema) and OWL (Web Ontology Language) come in. They provide formal mechanisms to derive new facts from existing ones and to constrain what is permissible.

Consider domain and range in RDFS. If we declare that "teaches" has domain "teacher" and range "student", then the statement "Bob teaches Scooter" lets us infer that Bob is a teacher and Scooter is a student. If we further declare that all teachers are persons, we can infer Bob is a person. None of this was explicitly stated in the original data. It was derived through logical entailment.

OWL extends this with more sophisticated constructs. Transitive properties let us chain relationships: if ancestor is transitive, and Sue is ancestor of Mary who is ancestor of Ann, then Sue is ancestor of Ann. Functional properties enforce uniqueness: hasFather is functional because you can only have one father. If the system encounters claims that Bob and BB are both father of Jim, it can infer that Bob and BB must be the same individual—or flag a contradiction.

These mechanisms matter because they give us principled ways to catch errors that would be nearly impossible to detect in pure text:

The Description Logic Handbook provides the formal foundations for these mechanisms [4], while the W3C's OWL 2 Primer offers practical guidance for implementation [5].

Agent Loops and the Danger of Unbounded Iteration

Modern AI agents operate through loops: perceive, reason, act, repeat. This is not new. Böhm and Jacopini proved in 1966 that any computable function can be expressed using just three constructs: sequence, conditionals, and loops [6]. With the addition of loops, agentic AI becomes Turing-complete—capable, in principle, of computing anything computable.

The problem is that loops can fail in ways that sequential code cannot. An agent might:

• Enter infinite loops—repeating the same action cycle without progress
• Drift from objectives—especially when multiple agents interact, each perturbing the others' context
• Accumulate costs—every iteration consumes tokens, and API bills can escalate rapidly

Here is a simplified example of how an agent loop works with an LLM like Claude:

while True:
    # LLM analyzes context and proposes tool use
    response = client.messages.create(
        model="claude-3-opus",
        messages=messages,
        tools=available_tools
    )
    
    # Check why the LLM stopped
    if response.stop_reason == "tool_use":
        # Execute the tool with parameters from LLM
        tool_result = execute_tool(
            response.tool_calls[0].name,
            response.tool_calls[0].input
        )
        
        # VALIDATION POINT: Check tool_result against ontology
        if ontology.validate(tool_result):
            messages.append({"role": "user", "content": tool_result})
        else:
            # Ontology detected inconsistency - halt or retry
            handle_validation_failure(tool_result)
    else:
        # LLM provided final answer without tool use
        break

The critical insight is where validation happens. The LLM proposes; the ontology validates. This is the architecture that keeps probabilistic systems honest.

The Architecture: Pydantic at the Door, Ontology at the Ledger

A practical pattern is emerging for building robust agent systems. It has two validation layers:

Pydantic at the door: Use Pydantic (or similar type systems) to validate that inputs conform to expected types and structures before they reach the LLM. This catches malformed requests early.

Ontology at the ledger: After the LLM proposes an action and the tool executes, validate the result against your domain ontology before committing any side effects. Does the output respect functional constraints? Are disjoint classes violated? Are values from the permitted enumeration?

This architecture has a crucial property: agents operate without side effects until validation passes. They can propose, simulate, and reason in a sandbox. Only when the ontology confirms consistency does the system commit to database changes, API calls, or other external effects.

Garcez et al. survey the broader landscape of neural-symbolic integration, showing how these hybrid approaches are being applied across planning, reasoning, and verification tasks [7]. The field has moved beyond academic curiosity to practical implementation.

Why This Matters for Enterprise AI

Enterprises deploying AI face a predictable set of challenges: compliance requirements demand explainability, safety-critical applications demand correctness, and operational systems demand consistency. Raw LLMs struggle with all three.

Ontologies address these needs directly:

Explainability: When a decision is questioned, you can trace not just what the LLM output, but what inferences the ontology derived. The reasoning is inspectable and auditable.

Correctness: Domain constraints encoded in OWL provide hard boundaries. A medical ontology can enforce that certain diagnoses require specific lab values. A financial ontology can enforce that transactions respect balance constraints.

Consistency: Functional properties ensure uniqueness. Transitive properties ensure that if A depends on B and B depends on C, the system recognizes A depends on C.

Berners-Lee, Hendler, and Lassila envisioned this in their 2001 Scientific American article on the Semantic Web: machine-readable data that enables software agents to carry out sophisticated tasks for users [8]. We now have the neural components they lacked. The missing piece was never the models; it was the disciplined integration of models with structured knowledge.

Getting Started: Practical Steps

If you are building or planning agent-based systems, consider these concrete steps:

1. Audit your existing data models. You likely have implicit ontologies in your database schemas, API specifications, and business rules. Make them explicit.
2. Start with existing taxonomies. Before inventing terms, check schema.org, industry standards, and open ontologies. Reuse reduces ambiguity.
3. Identify critical constraints. What must never happen in your domain? Functional properties, disjoint classes, and value enumerations encode these constraints formally.
4. Design validation checkpoints. Map where in your agent workflows ontology validation should occur. Typically: after LLM proposal, before tool execution, and before committing side effects.
5. Build incrementally. Start with a narrow domain, prove the approach, then expand. The expert systems of the 1980s failed partly because they tried to do too much at once.

Conclusion: Nothing is a Mistake, Only Make

Frank Coyle closes his talk with a quote from Sister Corita Kent, popularised by John Cage: "Nothing is a mistake. There is no win. There is no fail. There is only make."

This is the right posture for the current moment. The integration of agents and ontologies is not a solved problem. It is a space of active experimentation where the teams that ship, test, and iterate will learn faster than those waiting for perfect solutions.

The probabilistic revolution in AI has given us powerful new tools. The symbolic tradition gives us the discipline to use them responsibly. The convergence—neuro-symbolic AI—is where enterprise applications will be built. Not because it is fashionable, but because it is necessary. Systems that cannot explain their reasoning, cannot guarantee their constraints, and cannot verify their outputs will not be trusted where it matters.

The future belongs to those who can make both kinds of machines work together.

References

1. McCarthy, J., Minsky, M. L., Rochester, N., & Shannon, C. E. (1955). A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence. AI Magazine, 27(4), 12-14.
2. Gruber, T. R. (1993). A Translation Approach to Portable Ontology Specifications. Knowledge Acquisition, 5(2), 199-220.
3. Marcus, G. (2020). The Next Decade in AI: Four Steps Towards Robust Artificial Intelligence. arXiv:2002.06177 [cs.AI].
4. Baader, F., Calvanese, D., McGuinness, D., Nardi, D., & Patel-Schneider, P. (Eds.). (2003). The Description Logic Handbook. Cambridge University Press.
5. OWL 2 Web Ontology Language: Primer. (2012). W3C Recommendation.
6. Böhm, C., & Jacopini, G. (1966). Flow Diagrams, Turing Machines and Languages with Only Two Formation Rules. Communications of the ACM, 9(5), 366-371.
7. Garcez, A. d'Avila, et al. (2019). Neural-Symbolic Computing: An Effective Methodology for Principled Integration of Machine Learning and Reasoning. arXiv:1905.06088 [cs.AI].
8. Berners-Lee, T., Hendler, J., & Lassila, O. (2001). The Semantic Web. Scientific American, 284(5), 34-43.