Where LLMs Break and Why Ontologies Don’t

Executive Summary

• Fragments Are Not Answers: LLMs can already query databases and small graphs, but fail once semantics widen across “customer,” “contract,” “order,” and “vehicle” in one consistent logic. Aluna, digetiers’ semantic intelligence engine within d.AP, was built precisely for this frontier. Preserving meaning instead of flattening it into tables.
• Ontology-Grounded, Not Schema-Mapped: Aluna reasons directly on an ontology-grounded knowledge graph, interpreting questions against the enterprise’s entities, relationships, and constraints rather than one application’s schema. It resolves meaning, generates a live SPARQL query, and returns an answer grounded in your model, with the logic behind it visible.
• Comprehension Is the Real Bottleneck: Query generation is not the hard problem; comprehending ontologies spanning dozens of domains is. Aluna’s orchestration layer performs schema exploration, vocabulary recognition, and taxonomy traversal so the model reasons with global context, not isolated fragments.
• Grounding for Every AI System: Aluna is not only an interface for people. Through open protocols like MCP and A2A, it serves the same comprehension to external copilots and agents as a persistent grounding service, so every system in the enterprise reasons on the same semantics.
• From Analysis Toward Action: Aluna is today the analytical heart of d.AP. The same semantic foundation is designed to extend toward configurable micro-operations: validated, explainable actions triggered by the same understanding used for analysis.

Introduction

The phrase “chat with your data” has become the shorthand for making analytics conversational. And yes, today’s large language models can already query databases, interact with APIs via MCP servers, and even handle small graph-based datasets. But as soon as the semantic scope widens when “customer,” “contract,” “order,” and “vehicle” must coexist in one consistent logic these systems begin to fail. They answer fragments of questions, not the question itself.

At digetiers, we built Aluna precisely for this frontier. Aluna is not another interface for querying structured data. It is the semantic intelligence engine of our d.AP platform, an orchestration layer designed to interact with very large enterprise ontologies and deliver semantically correct analytics in natural language. Where others flatten meaning into tables, Aluna preserves it.

Understanding Aluna

Aluna represents the convergence of three disciplines that rarely meet in one product: knowledge graph reasoning, ontology comprehension, and language-model orchestration. It sits between the user and the data, translating natural-language intent into fact-based logic.

Unlike conventional “semantic layers,” which often rely on fixed SQL mappings or narrow metadata models, Aluna operates directly on an ontology-grounded knowledge graph. This means that each question is interpreted against the conceptual model of the enterprise: its entities, relationships and constraints, rather than through the limited lens of one application schema.

The result is precision. When a user asks “Which customers have active contracts but open service tickets?”, Aluna doesn’t stitch together text embeddings or pre-built joins. It reasons through the graph, resolves meaning, generates an optimized SPARQL query, and executes it live returning not an approximation, but an answer grounded in your model.

And every answer carries its reasoning with it. Where the data came from, which filters, joins and aggregations were applied, how Aluna arrived at the conclusion, all of it inspectable. This is not a reporting feature. It is what makes an answer usable in an environment where someone will eventually ask why the number says what it says.

Not Only for People

An assistant that answers questions in natural language is the visible half of Aluna. The other half is that the same comprehension is exposed as a service.

Through open protocols like MCP and A2A, external copilots, agents and agent-based systems connect to Aluna directly and receive the semantic grounding they need to reason reliably. Applications consume the same knowledge through REST APIs; analytics platforms consume it as aggregated data products. One governed understanding, served consistently, whether the consumer is a person or another AI.

This matters because the alternative is what most enterprises are building today: every new AI use case reconstructing business knowledge from scratch, each agent fluent in one system and unintelligible to the next. Aluna is designed to be the shared layer underneath them rather than one more endpoint beside them.

The language models Aluna orchestrates are hosted in Europe and treated as a modular component, refined and replaced as better options appear. The comprehension lives in the semantic layer, not in any single model.

Why Aluna Scales Where Others Stop

The real challenge in enterprise-scale semantic intelligence isn’t query generation, it’s ontology comprehension. Traditional systems handle small, single-domain graphs; Aluna was designed for ontologies that span dozens of domains.

To do this, we engineered an orchestration layer that helps the underlying model understand large schemas before reasoning over them. This includes dedicated mechanisms for schema exploration, vocabulary recognition, and taxonomy traversal, allowing Aluna to identify which parts of the ontology are relevant for a given question without losing global context.

These instruction layers teach the model how to choose between different query patterns, how to combine reasoning paths efficiently, and how to minimize computational overhead while maintaining interpretability. None of this is exposed to the user, but every answer reflects it.

This is the difference between a semantic layer that maps data and one that understands meaning. Most platforms can expose metadata; Aluna exposes comprehension.

From Questions Toward Operations

Aluna today is the analytical heart of d.AP: an assistant that translates language into analytics over live data. But the same foundation opens the path toward something more powerful: closing the loop between insight and action.

The same semantic foundation is designed to extend toward configurable micro-operations, tasks that act on the same semantic understanding they analyze, always validated, always explainable.

While we are selective in how much of this roadmap we reveal, one thing is clear: the trajectory is toward an AI that doesn’t just answer questions it understands what to do with them.

Conclusion

In a market filled with “semantic layers” and “chat-with-data” tools, most solutions still rely on predefined mappings or limited graph fragments. They make data accessible, but not truly intelligible. Aluna was built for a different class of problem: reasoning across complex, interconnected ontologies where context, hierarchy, and business logic matter as much as the data itself.

That capability doesn’t emerge from a single algorithm it comes from the deep fusion of ontological modeling, orchestration design, and language reasoning expertise. It is this synthesis that allows Aluna to scale, to remain accurate as graphs grow, and to make meaning operational across the enterprise.

Where others translate syntax, Aluna understands semantics. And that makes all the difference.