{
  "video": {
    "id": "Sir59K8ZDPU",
    "title": "Why Agentic Systems Need Ontologies — Frank Coyle, UC Berkeley",
    "duration": 1278,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer",
    "event_format": "In person"
  },
  "analysis": {
    "video_id": "Sir59K8ZDPU",
    "title": "Why Agentic Systems Need Ontologies — Frank Coyle, UC Berkeley",
    "one_liner": "A Berkeley educator argues that ontologies (RDFS/OWL graph schemas) should sit inside the agent loop as a validator — Pydantic at the door, ontology at the ledger — to catch the nonsense a probabilistic LLM will otherwise happily emit.",
    "summary": "Coyle traces two lineages — agents back to McCarthy, Selfridge and Minsky and the 1956 coining of 'artificial intelligence', and ontologies back to Aristotle's categories of being through Quine to Gruber's 1993 definition of 'a formal specification of a shared conceptualization' — and argues their convergence is what people now call neuro-symbolic AI. His claim is that hallucination is a feature of LLMs, not a bug, so the fix is guardrails rather than better prompting: a reasoner built on RDFS/OWL that checks tool results before they're accepted. He walks through a Claude agent loop in Python (while True, call the model with a tool, check stop_reason, execute on tool_use) and marks the spot after the tool runs where a validator should sit, sending unreasonable results back to the LLM or to a human. He closes with concrete OWL error classes an ontology catches that English cannot: a second refund on the same order, a payout routed to a support rep instead of the buyer, and an invented status like 'probably shipped'.",
    "key_points": [
      "Gruber's 1993 definition anchors the talk: an ontology is 'a formal specification of a shared conceptualization' — and that conceptualization of our domain is what we owe our agents.",
      "Hallucination is framed as a feature, not a defect: 'that's actually a feature of large language models. It's who we are. We hallucinate in a way.' Neuro-symbolic AI keeps the probabilistic LLM on guardrails.",
      "Ontologies are just entities, properties and relationships in a graph; graph databases arose because relational tables were too restrictive — adding something new means a new column and redoing the structure, where a graph lets you just attach another property or relationship.",
      "Two construction routes: top-down (domain experts enumerate purchase orders, customers, customer reps and their relationships — the 1980s expert-systems model) and bottom-up (harvest entities from things like customer interactions and add them to the graph).",
      "Reuse existing taxonomies rather than reinventing: schema.org, FOAF (Friend of a Friend) for social networks, Dublin Core for describing research papers and books, and DBpedia, which Coyle says underlies Wikipedia search as a giant graph database.",
      "RDFS and OWL sit beside the graph and generate inference: domain/range means 'Bob teaches Scooter' yields Bob is a teacher and a person, Scooter is a student; transitive properties chain ancestor-of from Sue to Mary to Ann; functional properties ('has father' — only one) let you infer Bob and BB are the same individual.",
      "Bohm and Jacopini (1966) settled the Fortran-vs-COBOL argument: sequence, conditionals and iteration make a language Turing complete. Loops are the last piece agentic AI needed — but loops break, drift as agents talk to each other, and run up token counts.",
      "Live Claude agent code: a `while True` loop where the response carries model, prompt and tool; the LLM can't execute anything ('I'm just locked in this box'), so it returns parameters; check `stop_reason`, and on `tool_use` execute the tool. The red annotation marks where the ontology validator goes — after the tool runs, before the result is accepted.",
      "OWL catches errors that are very tricky to express in English: a second refund on the same order, a payout sent to the support desk instead of the buyer (a disjoint property separating customer and support rep), and a made-up status value like 'probably shipped' when the only legal values are paid, shipped or refunded."
    ],
    "takeaways": [
      "Put a validator inside the agent loop, right after the tool returns: if the result is reasonable, proceed; if not, send it back to the LLM or escalate to a human in the loop.",
      "Layer two kinds of checking — 'Pydantic at the door, ontology at the ledger': Pydantic adds types to Python's untyped variables to check parameters, and the ontology checks the results.",
      "Keep agents pure and side-effect-free — don't let them change things in the database until the result has passed through the ontology.",
      "Encode business constraints as OWL disjoint, functional and enumerated-value properties (status must be paid, shipped or refunded, nothing else) rather than hoping prose instructions hold.",
      "Start from existing vocabularies — schema.org, FOAF, Dublin Core — which have had 15–20 years of work, instead of building an ontology from zero.",
      "Coyle's learning advice: make things rather than read about them, and take notes by hand — when you type, your brain is on the letters on the keyboard; when you write, your whole sensory system is engaged."
    ],
    "topics": [
      "agents",
      "ontologies",
      "knowledge-graphs",
      "neuro-symbolic-ai",
      "guardrails",
      "owl-rdfs",
      "validation",
      "ai-history"
    ],
    "tools": [
      "Claude",
      "Pydantic",
      "Python",
      "OWL",
      "RDFS",
      "schema.org",
      "FOAF",
      "Dublin Core",
      "DBpedia",
      "Wikipedia",
      "Nvidia",
      "Fortran",
      "COBOL",
      "codesupreme.ai"
    ],
    "quotes": [
      {
        "text": "It is a a formal specification of a shared conceptualization. And that's what we want to give to our agents. We want to give them our concept our conceptualization of the universe, our universe, our domains.",
        "at": "03:51",
        "url": "https://www.youtube.com/watch?v=Sir59K8ZDPU&t=231s"
      },
      {
        "text": "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.",
        "at": "05:02",
        "url": "https://www.youtube.com/watch?v=Sir59K8ZDPU&t=302s"
      },
      {
        "text": "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.",
        "at": "15:46",
        "url": "https://www.youtube.com/watch?v=Sir59K8ZDPU&t=946s"
      },
      {
        "text": "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.",
        "at": "18:23",
        "url": "https://www.youtube.com/watch?v=Sir59K8ZDPU&t=1103s"
      }
    ],
    "words": 3619
  },
  "summary_url": "/#Sir59K8ZDPU",
  "transcript": {
    "html": "/transcripts/Sir59K8ZDPU.html",
    "txt": "/transcripts/Sir59K8ZDPU.txt",
    "vtt": "/transcripts/Sir59K8ZDPU.vtt"
  }
}