Why enterprise customer service needs neurosymbolic AI, not just LLMs
Generating tangible business value from AI deployments is still a challenge. In our line of work, this shows when moving from a controlled demo into production: a project that took a year and a half and a serious budget to build can still be unusable because the system can't guarantee decisional consistency - that the same decision be applied with rigor every time in the same scenarios.
That's not a training problem. It's a structural problem.
Structural Gaps in Previous Generations of Models
The industry has spent most of its effort on intent detection — classifying what a customer says into a predefined category — because it's the tractable part of the problem. It's also a minority of the problem. Research on real task-oriented dialogue, across independently annotated corpora, consistently finds that only about 30–40% of conversational turns express a clear, classifiable intent. The rest does other work: grounding, clarification, repair, coordination. A customer saying "I was looking at the car loan, but maybe I'd rather extend the mortgage... actually, what would you recommend?" is exploring, doubting, referencing context, changing topic, and asking for a recommendation — with no single operational intent to classify. Systems tuned for intent detection handle the minority well and mishandle the majority, because the majority isn't an edge case. It's most of what conversation actually is.
Dialogue is itself a business process, not just an interface to one. It's tempting to treat conversation as a thin layer that collects information before a backend system makes the real decisions. But every turn already involves decisions with business consequences: what to ask next, when to clarify versus assume, how to handle a topic change, when to escalate. When those choices are left to a language model with no explicit governance, the same situation can be handled differently across conversations, with nothing to explain why.
Ultimately, asking one paradigm to do everything doesn't work well. Current approaches ask an LLM to simultaneously understand language, apply business rules, manage dialogue state, stay consistent, and explain itself — tasks with genuinely different requirements, requiring differing capabilities. Language processing benefits from flexibility with variation and ambiguity. Business decisions need guarantees: consistency, traceability, auditability. It's the same reason an LLM solving a math problem doesn't do the arithmetic itself — it understands the request and hands the calculation to a pre-built algorithm to guarantee a correct answer. Conversational AI benefits from the same separation, even though it's applied far less often.
The Architecture: One Governed Space, Not a Stack of Layers
Most attempts to fix this add guardrails, rule layers, or retrieval systems around an LLM that's still doing the core reasoning — an improvement, but still a stack of layers bolted together at the edges rather than a single coherent system.
The core idea behind our conversational system, Lekta Noema, is to separate understanding language from making decisions. LLMs are general by design, that's their strength, but a bank's loan policy, an insurer's claims procedure, or a telco's service rules consist of thousands of interdependent, constantly changing, organization-specific rules. Trying to hold them in a context window or a prompt runs into real limits — rules get interpreted differently across invocations, a policy change means updating every relevant prompt by hand, and there's no way to verify the model actually applied the rule you intended. This all makes pure LLM systems undeployable in production.
The premise behind the neurosymbolic AI is the separation of responsibilities. A language model reads what the customer said and turns it into structured meaning. That extracted meaning is passed to a symbolic engine: a separate, deterministic rules layer that evaluates it against your business logic (rule → condition → action) and makes the actual decision, the same way every time, no matter how the ask is phrased (a principle called semantic invariance). A language model then communicates that decision with the customer.
So, the symbolic (deterministic) engine governs, and the LLM is consumed as an encapsulated service for linguistic tasks only. Concretely, the LLM appears at exactly two bookends of each conversational turn, and never in the middle. The flow represented as runtime is:
- User input → NLU (LLM). The language model does comprehensive understanding: entities, sentiment, pragmatic/discourse inference, understanding that "I want a loan," "necesito un préstamo," and "can I borrow money?" are in fact the same request.
- The system locates the conversation within the CBS (Conversational Business Space). The CBS is the deterministic "map" of everything that governs a conversation. It includes what the customer wants, what's already happened, and which rules and policies apply. Placing the turn on this map determines which rules and dialogue strategy come into play next.
- Rule engine makes the decision deterministically. The full reasoning chain is preserved (which rules fired, conditions evaluated, data consulted, etc.).
- Dialogue engine picks the next action from an explicitly defined strategy (clarify, disambiguate, recover, etc.).
- NLG (LLM) phrases the response naturally and on-brand.
- State is persisted and the trace is recorded for audit.
The LLM's sole job is translation at the edges: language-in/meaning-out at step 1, decision-in/language-out at step 5. Every decision, from eligibility, next question, whether a policy is satisfied, to what action to execute, happens in the deterministic layer. The LLM proposes and interprets; it never decides or executes. This results in semantic invariance: the business logic stays identical regardless of how the request was phrased or which LLM processed it.
The result is a system that feels conversational and adaptive on the surface, while every consequential decision underneath is made by defined logic that can always be inspected. Every decision is logged with its full reasoning chain by construction, and the same trace data is used to satisfy an auditor.
Where This Leaves Agentic AI
As agents take on more autonomous planning and execution, the governance question gets harder, not easier — an agent deciding which action to take needs the same consistency guarantees as one deciding loan eligibility, and a multi-step agent process needs traceability at every step, not just at the end. The architecture described above is what makes agentic behavior viable in an enterprise context in the first place: agents operating within explicit, verifiable boundaries, every action logged with its reasoning, and multiple agents coordinating through the same governed space rather than each improvising independently.
This Doesn't Get Less Relevant as Models Improve
A fair question: if LLMs keep getting better, does any of this still matter? We think the two are complementary, not competing. Every improvement in language models makes the language-handling half of this architecture more capable — better understanding, better generation, better reasoning all flow straight through. And the next real jump in capability increasingly looks architectural rather than a matter of pure scale: how components are combined, how decisions are structured, how knowledge is integrated. Separately, even a model that gets a decision right 99% of the time is a different thing from a decision that's verifiably correct — and for compliance purposes, that difference doesn't shrink just because the model gets better. The line between what a model can be trusted to do directly and what benefits from explicit governance may move over time. It will never disappear.