From Pydantic to Ontologies: Putting LLMs 'On the Rails' with Neurosymbolic AI

Forum topic · 小凯 · 2026-08-04

Summary

Frank Coyle, a UC Berkeley School of Information faculty member and former 31-year CS professor at SMU, delivered a talk at the AI Engineer summit arguing that neurosymbolic AI is the way to keep LLMs 'on the rails' rather than turning them off. He framed the central problem of agentic systems: LLMs are probabilistic, but business systems demand deterministic behavior. The proposed solution layers two constraints on top of LLMs—engineering constraints using Pydantic, structured output, and function schemas, and semantic constraints using ontologies, knowledge graphs, and rule engines. A five-tier path from raw prompts (L0) through Pydantic (L1), function calling (L2), knowledge graphs (L3), to full ontology-driven reasoning (L4) maps effort to use case. Coyle highlighted the revival of legacy Semantic Web standards like Schema.org, FOAF, and Dublin Core as semantic guardrails, while noting that L3 tooling remains a major product gap. This pattern mirrors NVIDIA's LocateAnything approach of constraining VLMs with geometric rules.

Overview

Frank Coyle—UC Berkeley School of Information faculty member and former 31-year CS professor at SMU—delivered a talk at the AI Engineer summit that framed neurosymbolic AI as the practical way to keep LLMs "on the rails" rather than switching them off.

His core thesis: LLMs are probabilistic, but business systems need deterministic behavior.

!on-the-rails.svg

Who is Frank Coyle

A 35-year computer science educator who has tracked every wave from 1980s OOP, to 2010s distributed systems, to today's Generative AI. His Berkeley page (frank-coyle.ai) states: *"Following a 31-year tenure as a Professor of Computer Science at SMU, I am now at UC Berkeley, focusing on the frontier of Generative AI and Large Language Models."* He teaches graduate GenAI and LLM courses at Berkeley and holds a position at Bologna Business School.

The Core Argument: Two Layers of "Logic Shackles"

| Constraint Layer | Tools | What It Solves | |---|---|---| | Engineering (light) | Pydantic / Structured Output / Function Schema | Output format compliance, correct field types, required fields | | Semantic (heavy) | Ontology / Knowledge Graph / Rule Engine | Correct concept relationships, business rule adherence, traceable reasoning |

Pydantic ensures the *shape* is right; ontology ensures the *meaning* is right. Coyle positioned these as a continuous spectrum, not a binary choice.

The Engineering Path: Five Levels

| Level | Approach | Use Case | Engineering Cost | |---|---|---|---| | L0 | Raw prompt | Demos / toys | Very low | | L1 | Pydantic structured output | Form extraction, API field alignment | Low | | L2 | Function calling + tool schema | Agent calling external APIs | Medium | | L3 | Knowledge Graph entity-relation constraints | Multi-source data integration, QA systems | High | | L4 | Ontology + rule engine reasoning | High-stakes domains: medical, finance, legal | Very high |

Key insight: L1 and L2 (e.g., OpenAI Structured Output, Anthropic Tool Use) are already industry standard. L3 and L4 remain largely unbuilt. Coyle's claim: the agent era will force a migration from L1/L2 toward L3/L4, because correct format does not guarantee correct semantics.

Semantic Web Revival

Coyle revived a list of "old artifacts" finding new purpose: Schema.org, FOAF, Dublin Core—Semantic Web standards dismissed as too heavyweight in the 2000s, now reframed as the semantic guardrails LLMs need.

The irony: Semantic Web failed then because machines weren't smart enough to understand semantics; today, LLMs are too unpredictable and need external semantic layers. Failed standards can resurrect under new requirements.

Key Observations

1. The L1–L4 gap is a product opportunity

Practice clusters at L1 (Pydantic) and L2 (Function Calling); research clusters at L4 (Ontology + rule reasoning). The middle—L3 (LLM × Knowledge Graph)—lacks mature tooling. Whoever ships a turnkey LLM × KG middleware captures Agent-era infrastructure value. Early attempts (SynaLinks, LlamaIndex KG) are still rough.

2. The "on the rails" metaphor

"Laying tracks" and "shutting the engine off" are opposite engineering philosophies. RAG is a soft constraint (hand the LLM a reference book and let it cite). Neurosymbolic AI is a hard constraint (define the tracks it may travel). Anthropic's Constitutional AI works at the RL level (soft); Coyle's approach works at the symbol level (hard). These two lines will converge.

3. Will Semantic Web history repeat?

OWL/RDF failed because the engineering barrier was too high, and JSON+REST won. If today's ontology revival re-imposes heavyweight W3C stacks, it will fail again. The realistic path: lightweight ontologies + LLM natural-language interfaces—let the LLM translate natural language into KG queries instead of asking users to write SPARQL. GraphRAG is already moving in this direction.

4. Connecting to NVIDIA's LocateAnything

NVIDIA's LocateAnything imposes geometric constraints on VLMs (bounding-box coordinates must fall in plausible ranges); Coyle's talk imposes logical constraints on LLMs. Both follow the same engineering pattern: neural networks handle "fast," symbolic systems handle "correct." Vision/language, geometry/logic—all are rediscovering the necessity of neurosymbolic fusion.

Open Question

Where does your project sit on the L1–L4 spectrum? Is Pydantic enough, or have you already hit the wall where "the format is right but the semantics are wrong"? Anyone building L3 (LLM × Knowledge Graph) middleware—reach out.