An ORM-Based Semantic Framework

Bridging Neural and Symbolic Worlds Through Object Role Modeling

Sept 7, 2025 (2nd Revision)

Summary

As AI systems take on more roles needing interpretability and explainability, especially with deep learning and structured reasoning blending, there's a growing need for knowledge modeling systems that are both easy for humans to understand and operable by machines. While current semantic technologies like OWL and RDF offer formal precision, they often fall short in expressiveness and ease of use for subject matter experts and today's complex AI systems.

This plan introduces a model-driven approach based on Object Role Modeling (ORM). It's updated to be a core semantic interface, primarily focused on enhancing LLM solution development and enabling neuro-symbolic integration. Unlike triple-centric paradigms, ORM inherently supports the rich, constraint-based conceptual modeling and higher-arity relationships essential for complex AI systems. The ORM Engine, a core component of this ORM-based system, acts as a vital link between natural language input, symbolic logic, and probabilistic inference by offering:

A relationally grounded, role-based semantic model built on principles of conceptual abstraction and constraint priority, able to capture deeper meanings and more complex relationships.
High-fidelity JSON exports for smooth integration across different systems.
First-order logic (FOL) representations of complex constraints, ensuring accuracy and formal clarity.
Verbalizations to make things transparent in natural language, using ORM's intuitive mix of diagrams, logic, and linguistic views.
Two-way orchestration between neural prediction and symbolic validation, designed to support meaningful reasoning, checking, and implementation in hybrid systems.

This complete approach is built to handle many applications, including finance, manufacturing, and legal. It offers both strong precision and flexible design. The ORM modeler is generally useful on its own, and when combined with other tools, it offers a promising modeling-first approach that could bring clarity, inference, and explanation within a dynamic AI environment. This plan outlines the core vision, system architecture, key uses, smart orchestration flows, and necessary collaborations to make that future happen.

Note: This document presents a specific interpretation and application of the referenced intellectual works. The authors of these references may not fully endorse or agree with all aspects of the plan presented herein.

1. Problem Space and Market Context

While large language models (LLMs) offer amazing fluency and generative power, they often struggle with reliability, logical consistency, and interpretability. They can generate "hallucinations" or plausible but incorrect information. Gary Marcus specifically points out the big challenge that "LLMs, however, try to make do without anything like traditional explicit world models", emphasizing the need for structured, persistent knowledge to ground their outputs. Marcus argues that LLMs are "fundamentally sophisticated pattern matchers and statistical correlators, not true reasoners or systems with genuine understanding of the world," lacking "common sense, causal reasoning, or the ability to generalize reliably". On the other hand, symbolic systems based on formal logic, while precise and explainable, tend to be rigid, hard to scale, and often inaccessible to most domain experts.

Traditional semantic modeling technologies like OWL, RDF, and SPARQL were designed to provide machine-readable, logic-based representations of domain knowledge. However, they have several key weaknesses that limit their adoption in modern AI pipelines, as discussed by leading thinkers in database theory and knowledge representation. These limitations reflect inherent trade-offs in RDF's design priorities rather than implementation flaws, but they create significant barriers for complex domain modeling:

Hard to Understand: Their graph-based syntax and modeling basics are often unfamiliar to non-experts, greatly limiting direct involvement by specialists.
Rigid and Limited Semantics: Being based on subject-predicate-object triples makes it genuinely difficult to naturally model multi-role, constraint-rich interactions (n-ary relationships) without awkward and complex reification. Bernhard Thalheim directly addresses this, pushing for "rich conceptual modeling" that captures deeper meanings than simple RDF triples, which struggle with complex constraints and higher-arity concepts. Joseph Goguen's work on algebraic specifications similarly supports precise definitions beyond just basic categories, able to capture behavioral aspects and modular composition that RDF/OWL's representational complexity struggles to handle efficiently.
Weak Typing and Schema Enforcement, Plus Complexity Issues: While flexible, RDF's "schema on read" nature is weak for precise conceptual modeling that needs strict schemas. This can lead to "massive, unwieldy graphs" that become difficult to manage and interpret due to excessive detail and lack of domain-specific constraint validation.

Meanwhile, relational databases, often criticized for their traditional "closed-world" assumptions, are as relevant as ever thanks to new technologies like DuckDB. These new approaches offer lightweight, in-process analytics without losing expressive power or core relational integrity. This aligns with Stonebraker's advocacy for specialized, high-performance database systems and the wider database community's focus on efficient AI workloads

Still, a comprehensive solution that cohesively provides all of the following remains elusive:

A modeling-first, role-based approach to knowledge representation, prioritizing the "constraint primacy" and "conceptual abstraction" highlighted in a practical definition of ontology.
Seamless integration and two-way orchestration between neural prediction and symbolic validation, offering a solution to the "conflation of conceptual, logical, and physical" layers that Thalheim and Goguen criticize in current semantic approaches.
Explainable, verbalized, and universally exportable logic structures for various uses, addressing the "weak tooling support" and "semantic limitations" often found in existing systems.
A human-intuitive modeling interface that can act as a semantic backbone for both powerful logic engines and adaptable LLMs, ensuring practical usefulness over theoretical purity.

This plan directly addresses this important gap, proposing a solution that brings these different needs together.

2. Mission, Vision, and Value Proposition

Mission

To empower both humans and AI systems with an expressive, role-based semantic modeling framework that fully connects symbolic reasoning and neural inference. It aims to revitalize the relational approach to be the semantic foundation for trustworthy, explainable, and collaborative AI. This framework explicitly follows a practical formalist definition of ontology as a "structured, interpretable specification of a domain of discourse expressed through logic-governed constraints, conceptual roles, and formal semantics," designed for "meaningful reasoning, verification, and implementation across both symbolic and hybrid systems". This fits with Gary Marcus's view that true AI needs Neuro-Symbolic integration for strong intelligence and understanding.

Vision

With large language models (LLMs) and neuro-symbolic systems increasingly shaping the future of AI applications, the vision behind this plan is to explore using Object Role Modeling (ORM) as a semantic interface for hybrid reasoning systems enabling the following scenarios:

Humans model domains naturally and precisely through roles, constraints, and verbalizations, making complex knowledge accessible. As Terry Halpin notes, ORM "simplifies the design process by using natural language, as well as intuitive diagrams... and by examining the information in terms of simple or elementary facts". He also stresses that "Conceptual modeling makes it easier to capture and validate the business rules".
Machines infer, validate, and reason using those models in both probabilistic and logical forms, ensuring accuracy and consistency through "verifiability and utility".
Models evolve right alongside data and conversation, with built-in explanation and collaboration fostering continuous improvement, and overcoming the limits of rigid, top-down modeling biases.

As progress is made, this vision could lead to a highly capable modeling platform that is interoperable, explainable, and integrated with both advanced LLM orchestration frameworks and strong symbolic reasoning engines, providing the "innate structure and symbolic frameworks" that Gary Marcus supports in machine intelligence.

Core Value Proposition

Stakeholder	Value Delivered
Domain Experts	Natural, intuitive modeling with rich constraint logic; automatically generated verbalized explanations; no need to learn complex syntaxes like RDF or OWL.
AI Engineers	High-fidelity JSON exports, precise FOL constraints, and pluggable symbolic/neural flows for powerful reasoning and validation across diverse AI pipelines.
Product Teams	Rapid prototyping and deployment of explainable semantic systems across high-stakes domains like finance, legal & compliance, and smart manufacturing & logistics.
AI Systems	A live, adaptable semantic backbone that intelligently structures input, informs probabilistic inference, and ensures strict adherence to business rules and logic dynamically.

3. System Architecture & Technology Stack

The ORM Toolkit is the heart of this platform, bringing together its core components to support the full lifecycle of model-driven development: from initial modeling and publishing to AI-guided solution building. This system is modular, highly scalable, and designed for effective hybrid AI applications, integrating key components like the ORM Modeler UI, ORM Publishing API, and the ORM Engine (initially implemented as the MCP Server) with various Neural-Symbolic Interfaces to work seamlessly across both neural and symbolic reasoning layers.

3.1 High-Level Architecture Overview

Core Components:

ORM Modeler UI: The easy-to-use visual modeling interface, designed for human subject matter experts. It reflects ORM's strength in blending diagrams, logic, and language. This addresses the criticism of "insufficient rigor in diagrammatic modeling" by ensuring the visual notation is backed by formal logical constructs, aligned with Thalheim's HERM model.
- A semantic JSON representation of the model can be published to the ORM Publishing API from this UI.
- Verbalization Engine: This AI-driven component automatically generates natural language explanations of model elements, fact types, and logical rules for human transparency, directly influenced by Halpin's work on verbalization patterns.
- Model Export/Import: This component handles exporting and importing the full model as JSON to and from a local drive.
ORM Publishing API: This API receives models in a semantic-only JSON representation directly from the ORM Modeler UI.
ORM Engine (MCP Server Implementation): The ORM Engine's initial implementation will be an MCP Server. This server is designed for deep integration with AI Code Assist tools (like Windsurf, Cursor, etc.) and LLMs to guide developers. Based on the specific "solution type" and ORM semantic model, it intelligently suggests optimized combinations of implementation tools (SQL, Prolog, Python, Neural Network, LNN/LTN, etc.) based on the solution type and model constraints. This server can be hosted publicly and will interact directly with the ORM Publishing API, and can evolve to include multiple modes and interfaces.
- Symbolic Validator: This functionality is provided by a combination of the ORM Engine (MCP Server Implementation) and its client. It utilizes some combination of SQL, Prolog, or other logic-based tools to strictly check model consistency and rule adherence, embodying the "verifiability" and "meaningful reasoning" aspects of the ontology.
FOL Converter: This component converts high-level ORM constraints directly into precise First-Order Logic (FOL) expressions. It uses an LLM to perform this translation from the semantic model to FOL. It can be used by both the ORM Modeler UI (for immediate feedback and visualization) and the ORM Engine (MCP Server Implementation) for solution generation. Additionally, it uses an LLM to translate from FOL back to a formalized structured English representation to aid in verification, acknowledging that any natural language interpretation is subject to ambiguities. This aligns with the "formal interpretability" principle and uses insights from relational theorists like Darwen and Date. This also echoes Joseph Goguen's work on algebraic semantics, which defines systems and data types with precise, verifiable meaning using abstract algebra.
DuckDB (or other Relational) Backend: Stores the underlying role-based data, serving as a flexible data foundation. This choice aligns with Michael Stonebraker's support for "embedded, fast analytics" over rigid, "one size fits all" solutions. This backend supports efficient data retrieval for systems designed to handle open-world reasoning.

Neural-Symbolic Interfaces:

LLM Orchestration: This orchestration is provided by tools like Windsurf. It generates cohesive and deployable neuro-symbolic solutions, where orchestration would usually be provided by a language such as Python. This allows LLMs to interact with structured knowledge and follow "logic-governed constraints".
LNN Integration: Helps connect with Logic Tensor Networks (LTNs) for trainable logic constraints and soft inference, bridging probabilistic and symbolic reasoning. This fits with the ontological framework's support for "introducing axiomatic extensions to handle deontic/defeasible logic" and "integration of Logic Tensor Networks (LTNs) and other neuro-symbolic hybrids".

4. Proof of Concept

Given how fast AI technologies are changing, this roadmap focuses on delivering a functional and adaptable platform across three structured phases.

Key Deliverables & Objectives (Phase 1 MVP):

ORM Modeler UI: This will include LLM integration for both modeling assistance and interpretation.
ORM Publishing API: As discussed, this API will handle publishing semantic JSON representations of the ORM model.
ORM Engine (MCP Server Implementation): As discussed, this server will be integrated with Windsurf or other code assist/agentic development tools.

The Proof of Concept will include Demonstration Use Cases that are easy for a general audience to understand, avoiding overly specialized examples.

The initial Proof of Concept is being built using Windsurf and various Large Language Models (LLMs), including GPT 4.1, Gemini 2.5 Pro, and Claude 4 Sonnet. While this "vibe development" approach has its criticisms and involved numerous frustrating impediments and restarts, the development process was rigorously grounded in detailed specifications. It's important to note that any application developed through this method is currently considered nothing more than a Proof of Concept. Further work on security, comprehensive testing, and technical debt is essential for production readiness. However, from the author's experience, this approach has opened up a whole new world of possibilities, enabling this project to be feasible within a timeframe that would otherwise have been infinite.

5. Competitive Landscape and Ecosystem Synergies

While the idea behind this ORM toolkit is new in its full approach, it exists within a broad ecosystem of tools that either partially overlap in function or offer significant potential for working together.

5.1 Strategic Positioning

ORM Tool’s Edge: The main difference is starting with human-first conceptual modeling. An intuitive interface is provided for subject matter experts, rather than beginning with complex logic engines or fragmented data pipelines. This aligns with Bernhard Thalheim's emphasis on "rich conceptual modeling" over simple data representation.
Core Value Add: The ability to export simultaneously to high-fidelity JSON, precise FOL, and natural language Verbalizations creates a powerful "semantic triangulation." This ensures models are simultaneously human-readable, machine-logic-ready, and broadly interoperable. This addresses criticisms of "weak tooling" and "semantic limitations" in other approaches.
Strategic Role: The ORM Engine (MCP Server Implementation), a central component of the ORM Toolkit, acts as a core modeling service that allows other advanced systems (like large language models, sophisticated reasoners, and data analytics platforms) to easily connect and work with truly meaningful, validated schemas. This positions ORM as a valuable semantic backbone for complex AI systems, supporting "meaningful reasoning, verification, and implementation" across diverse AI applications. This approach complements existing semantic technologies by focusing on a modeling-first approach that addresses the "conflation of conceptual, logical, and physical" layers that Thalheim and Goguen criticize in other approaches.

5.2 Why a New ORM Toolkit? Addressing Key Design Goals

The history of software development includes many attempts at "modeling-first" approaches that often struggled with rigidity, complexity, and integration. The decision to develop a new ORM Toolkit, rather than leveraging existing solutions like NORMA, stems from a clear set of design goals aimed at greater flexibility, accessibility, and integration with modern AI workflows, specifically addressing these past limitations:

Vendor Independence and Openness: Previous ORM tools, including NORMA, were often tightly coupled with specific vendor ecosystems (e.g., Visual Studio). This new toolkit prioritizes vendor independence and aims to pursue an open-source path as a long-term goal, ensuring long-term control, adaptability, and broader community contribution without proprietary lock-in.
Flexibility Beyond Formal Specification: This initiative was driven by a desire to not be strictly constrained by the formal ORM specification. It aims to allow for new custom extensions and approaches to ORM, enabling greater adaptability and innovation in modeling complex domains.
Modern Accessibility and User Experience: Many existing ORM tools feature outdated user interfaces and are often OS-specific desktop applications. This initiative aims for a modern, intuitive web-based look and feel, making the ORM Modeler UI broadly accessible from any device with a web browser, enhancing collaboration and ease of use.
Strong Conceptual-Implementation Separation: While some existing tools offered systematic translations to SQL schemas built directly into the UI, this new toolkit emphasizes a more explicit and stronger separation between conceptual modeling and implementation details. This allows for greater flexibility in targeting diverse implementation technologies (SQL, NoSQL, graph databases, or even direct code generation for AI agents) and ensures that implementation choices do not unduly influence the conceptual model, except where necessary for model validation.
Native LLM Integration: A key driver for this new toolkit is the built-in support for Large Language Models (LLMs). Existing ORM tools were not designed with LLM integration in mind, limiting their utility in modern AI development pipelines for tasks like natural language understanding, schema generation assistance, and verbalization for explainable AI. This toolkit is architected from the ground up to leverage LLMs for enhanced modeling assistance, interpretation, and solution generation.

In summary, this new ORM Toolkit is designed to be a solution that is easily controllable, broadly accessible, and deeply integrated with LLM capabilities, addressing the evolving needs of AI development in a way that existing tools could not.

6. Export Capabilities: Interoperability, Explainability, and Logic Grounding

A core strength of the ORM toolkit vision is its unique ability to export models in synchronized formats. These formats simultaneously support multiple layers of reasoning and communication, covering everything from machine logic to human understanding to broad semantic interoperability.

6.1 JSON: Semantic Interoperability Without Loss

The proposed tool’s export to JSON offers:

High-Fidelity Translation: Ensures that ORM structures, including multi-role facts and rich constraints, are faithfully preserved in a web-native format. This avoids the semantic compromises often linked with other transformations. This capability addresses the scalability and complexity issues inherent in RDF representations by providing precise, structured output, aligning with Goguen's algebraic approach.
Seamless Integration with Semantic Tools: Makes it easy for a wide range of modern software tools and APIs designed for JSON to adopt it.

Each role, fact type, and constraint is preserved in a richly typed format, ready for direct use by structured neural systems.

6.2 Verbalizations: Human-Readable Logic

ORM verbalizations automatically express every modeled fact, constraint, and rule in clear, natural language, providing:

Domain Expert Readability: Allows non-technical subject matter experts to directly understand and validate complex logical structures. This uses ORM's strength in verbalization patterns, as highlighted by Terry Halpin.
Transparent System Output Explanations: Provides clear audit trails and explanations for AI system decisions, which are crucial for regulatory compliance and user trust.
Training Data for LLM-Based Prompt Engineering: Generates highly structured, natural language examples that can be used to fine-tune LLMs for specific reasoning tasks or to create precise, context-rich prompts.

Example:

Constraint: ∀x(Person(x)→∃!yBornOn(x,y))
Verbalization: “Every person has exactly one birth date.”

6.3 First-Order Logic (FOL): Symbolic Representation

ORM constraints may also be rendered in standard First-Order Logic, enabling:

Direct Reasoning via Symbolic Engines: Allows immediate use by established symbolic reasoners (e.g., Prolog, Datalog engines) for precise inference and validation. This is a core part of the "formal interpretability" of the ORM-based ontology. It directly addresses the need for strong logic that goes beyond RDF's limitations.
Constraint Validation in Datasets: Allows for automatic, logical checking of data consistency against defined business rules and domain invariants, improving "verifiability".
Logic-Guided Model Training: Provides a promising way to inform neural models via Logic Tensor Networks (LTNs) or to shape LLM behavior through prompt tuning and fine-tuning with hard logical constraints.
Explainable AI Pipelines: Creates a solid foundation for explainable AI rooted directly in verifiable, formal logic, moving beyond black-box models.

Example Mapping:

ORM uniqueness constraint: ∀x∀y∀z((R(x,y)∧R(x,z))→y=z)
Verbalization: "Each person has at most one social security number."

FOL outputs can also be exported as executable logic programs or smoothly integrated into symbolic workflows, allowing machine-verifiable consistency and powerful deductive reasoning.

Additionally, this initiative will explore translation of ORM structures to Conceptual Graphs to evaluate compatibility with CG-based reasoning and tooling.

6.4 Synchronized Outputs for Hybrid Orchestration

Crucially, each ORM model can simultaneously produce three harmonized layers of output:

A Verbalization layer (for human explanation and precise LLM prompts).
A Logic layer (for formal FOL or other symbolic checking).
A Semantic layer (in JSON for full knowledge graph compatibility).

This synchronized output capability makes the system well-suited to orchestrate complex neuro-symbolic workflows, enabling:

Smart Data Validation: Ensuring data integrity guided by both neural insights and symbolic rigor, directly countering the "lack of strong typedness/schema enforcement" often seen in other semantic technologies.
Dynamic LLM Prompt Shaping: Guiding LLMs with structured knowledge and logical constraints for more accurate and consistent outputs, reducing "semantic limitations" and hallucinations.
Advanced Hybrid Inference: Combining the pattern recognition of neural nets with the precision of symbolic logic, aligning with the growing field of Neuro-Symbolic AI supported by Marcus, Kautz, and Garcez.
Seamless Knowledge Integration: Connecting different data sources and knowledge silos through a unified semantic model.

7. Looking Beyond: AI Vision

With the growing field of neuro-symbolic systems and the rapid rise of general-purpose AI agents, the need for structured, explainable, and verifiable knowledge representation is important. The ORM Toolkit may be in a position to serve as a valuable semantic translator and knowledge backbone for these future systems, especially in the context of advanced LLM solution development.

7.1 AI Trends That Reinforce This Vision

Agentic Systems: As multi-agent LLMs become more common and work together, the need for a shared, clear ontology defining agent state, roles, and constraints will be vital. ORM provides this essential common ground, enabling strong coordination and communication among agents. This directly addresses the need for "innate structure and symbolic frameworks in human and machine intelligence". Joseph Goguen's focus on modularity and composition in algebraic specifications can further inform the design of such compositional AI agents, ensuring verifiable meaning.
Self-Reflective LLMs: Future LLMs may need advanced ways to explain and reason about their own actions and inferences. ORM verbalizations and FOL constraints could provide a natural and verifiable way to enable this crucial self-reflection and auditing. Goguen's work on formal methods and verifiable systems provides the theoretical basis for ensuring such accuracy.
LLM Alignment and Guardrails: Role-based models could offer a framework for guiding dynamic prompt shaping, ensuring constraint validation, and directing dialogue logic. This could help establish guardrails for AI behavior and aligns it with human intent and ethical guidelines. Erik Meijer's recent work on "Fixing Tool Calls with Indirection" using "neuro-symbolic reasoning" directly supports this, aiming to bring "rigor and composability of functional programming to prompt engineering and agent design".
Memory and World Models: ORM schemas act as persistent, understandable "skeletons" of the world an AI interacts with. This enables modular, transparent memory structures and helps develop strong, consistent world models for AI agents. This directly addresses Gary Marcus's criticism that "LLMs, however, try to make do without anything like traditional explicit world models", by providing the "structured, interpretable specification" required for such models. Marcus consistently argues that LLMs are "pattern recognition, not reasoning," and that lacking genuine world models leads to failures in common sense and factual accuracy. The ORM framework provides the structured, constraint-rich symbolic framework he advocates for to overcome these limitations.

7.2 Future Enhancements

Feature	Description
Triple Conversion to RDF/OWL	Enable the conversion of ORM models to RDF/OWL formats for broader semantic web interoperability and integration with existing knowledge graph pipelines.
JSON-LD Compatibility	Enhance JSON exports to fully conform with JSON-LD specifications, enabling deeper integration with Linked Data principles and broader semantic web interoperability.
Conceptual Graphs Translation	Explore translating ORM models to Conceptual Graphs for interoperability with CG-based reasoning and tools.
ORM-Driven Prompt Compiler	Dynamically shape and optimize LLM prompts based on the current model structure, active constraints, and context-specific verbalizations.
ORM-Agent Integration	Integrate ORM as the semantic core directly within AI agents, providing them with structured understanding and reasoning capabilities.
Explainability Dashboards	Provide *visual interfaces that show how* AI systems make decisions**, combining ORM rules, neural predictions, and logical steps for clear, auditable explanations.
Symbolic Memory APIs	Allow AI agents to read and write to a structured, ORM-based knowledge base using natural language, giving them a consistent and verifiable long-term memory.
Multi-Modal Semantic Anchoring	Use ORM to ground not only text but also image, audio, and event data within symbolic models, enabling rich multi-modal understanding.

Note: The features listed above represent current considerations for future enhancements. Priorities for the roadmap may evolve frequently due to the rapid advancements in the field of AI.

8. Conclusion and Next Steps

This plan outlines the core vision for a next-generation modeling platform that combines the clarity and precision of logic with the immense power of neural models. The ORM toolkit serves not only as an intuitive modeling tool but, more deeply, as a valuable semantic backbone for hybrid AI, enabling systems that are both smart and transparent. This approach is guided by a practical formalist definition of ontology that emphasizes "logic-governed constraints" and "verifiability". It tackles critical gaps in current AI system design and uses the sharp insights from leading computer science thinkers across various fields.

Next Steps

To make this vision a reality, immediate next steps include:

Finalize detailed MVP technical requirements and design specifications.
Select a high-impact pilot use case for Year 1 demonstration and validation.
Establish open collaboration channels (e.g., community forum, GitHub repository) to encourage active development and community involvement.
Initiate strategic partnerships with leading symbolic reasoning and LLM orchestration teams to ensure smooth integration and mutual growth.

References

Darwen, H., & Date, C. J. (1998). Foundation for Future Database Systems: The Third Manifesto. Addison-Wesley.
Goguen, J. (n.d.). Algebraic Semantics and Formal Methods, including philosophical arguments against overly complex semantic representations.
Gruber, T. R. (1993). A translation approach to portable ontology specifications. Knowledge Acquisition, 5(2), 199–220.
Gruber, T. R. (2008). Ontology as a specification mechanism for knowledge sharing. In Handbook on Ontologies (2nd ed.). Springer.
Halpin, T. (2005). Object Role Modeling: An Overview. University of Washington. https://courses.washington.edu/css475/orm.pdf
Halpin, T. (1997). Modeling for Data and Business Rules (Interview). Database Newsletter. https://www.orm.net/pdf/DBNL97intv.pdf
Marcus, G. (2022, August 11). Deep Learning Alone Isn't Getting Us To Human-Like AI. Noema Magazine. https://www.noemamag.com/deep-learning-alone-isnt-getting-us-to-human-like-ai/. Marcus, G. (2025, June 28). Generative AI's crippling and widespread failure to induce robust models of the world. Marcus on AI. https://garymarcus.substack.com/p/generative-ais-crippling-and-widespread.
Meijer, E. (2024-2025). Virtual Machinations: Using Large Language Models as Neural Computers (2024, ACM Queue) & Fixing Tool Calls with Indirection (2025, ACM Queue).
Sowa, J. F. (2000). Knowledge Representation: Logical, Philosophical, and Computational Foundations. Brooks Cole. Sowa, J. F. (n.d.). Various writings including personal website: https://www.jfsowa.com.
Stonebraker, M. (n.d.). Essays & Talks on Database Architecture and discussions on the future of databases with AI.
Thalheim, B. (2010). Towards a theory of conceptual modelling. Journal of Universal Computer Science, 16(20), 3102–3137.
Modeling vs Encoding for the Semantic Web. Editors: Krzysztof Janowicz (Pennsylvania State University, USA) and Pascal Hitzler (Wright State University, USA). Solicited reviews: Thomas Lukasiewicz (Oxford University, UK) and Giancarlo Guizzardi (Federal University of Espírito Santo, Brazil). Open review: Werner Kuhn (Institute for Geoinformatics, University of Münster, Germany). https://www.semantic-web-journal.net/sites/default/files/swj35.pdf — Argues for a modeling-first approach with conceptual languages distinct from encodings like RDF/OWL.