Author(s): Marco van Hurne

Originally published on Towards AI.

One of the ways I keep myself busy in the AI domain is by running an AI factory at scale. And I’m not talking about the metaphorical kind where someone prompts an AI to write motivational LinkedIn posts about “scaling innovation”. No, this is the actual kind where we automate enterprise processes at volume, and it is a place where mistakes propagate through systems that move lots of money, grant access, and make decisions that lawyers and governments will ask about six months later. And I have learned something that the frontier model evangelists do not mention in their keynote demos, that Generative AI is a spectacular foundation for creativity and that it’s also a catastrophic foundation for systems that cannot afford to guess, if you leave them unchecked.

See content credentials

Large language models are linguistic savants. They’re very good at translating intent into structure, and in my case, the machine occasionally produces metaphors that are so apt that I wonder if the machine is mocking me. They are also chronic liars — not malicious — but more of the structural kind. They hallucinate because hallucination is how they make creative leaps. They hallucinate because hallucination is the mechanism that makes them interesting but when you keep it, you inherit a system that will invent API parameters, fabricate regulations, and propose infrastructure changes that sound authoritative while violating basic physical laws.

Take for instance my latest run in with hallucination. I posted it on LinkedIn last Sunday.

Manus faked an entire 100 page research result and when I caught it lying, it casually stated — probably with a smug grin — “they don’t actually exist on GitHub…. YET!”

And that’s exactly the Faustian bargain, the same mechanism that lets them create weird ideas is also what makes them invent facts. You cannot simply turn off the hallucination switch, but you can tweak it — which the industry is able to do better and better with each new release — but if you make the model too conservative and locked-down, you will kill the very essence that makes it useful and what you’re left with is an extremely expensive dictionary that only tells you things it has seen before, exactly as it saw them and that will not lead to new insights or surprising connections‡. Just retrieval.

This is not a bug though, but inherent to what transformer architectures do. They predict the next token based on patterns they learned across vast corpora of human expression, and they choose the most likely outcome, but they do not consult a database of verified facts or check constraints. They simply estimate plausibility and when plausibility and truth diverge, the model does not notice because its training objective was never to “be correct”, but to “continue the sequence in a way that resembles how humans write” and in a chatbot that is recommending me lunch spots, this is harmless, but when I’m implementing it in an autonomous system processing payments. . . Man, this is arson waiting for a match.

The thing that makes me a tad uncomfortable about the 2026 AI Automation rush†, is that enterprises are deploying these systems into environments where failure is asymmetric. Ninety-nine correct decisions do not erase one catastrophic mistake. This means a misconfigured firewall does not average out, or a fraudulent transaction does not become acceptable because the previous thousand were legitimate. Tail risk dominates and probabilistic systems reason about density, but not tails, and this specific mismatch cannot be solved by changing the training process. It is an inherent category error.

But there’s hope.

And the hope lies in the recent past of AI, the time when Neural Networks weren’t so sophisticated as they are now, but still were capable of helping people make decision. Yes, my smart friend, this is where symbolic AI re-enters the conversation, and it is wearing the same sensible shoes it wore in the nineteen-eighties yet still unfashionable as ever, but still correct.

See content credentials

‡ For more on creativity and AI:

• Human + AI thinking are colliding, and I made it worse on purpose | LinkedIn
• Attention isn’t all you need: The wanderer’s algorithm | LinkedIn

† For more AI Automation experiences:

• AI makes your company average | LinkedIn

More rants after the messages:

1. Connect with me on Linkedin 🙏
2. Subscribe to TechTonic Shifts to get your daily dose of tech 📰
3. Please comment, like or clap the article. Whatever you fancy.

The competence of symbolic AI

Symbolic AI is the disciplined older sibling that neural networks spent two decades trying to escape before becoming adolescent transfomer-based Generative models. Neural nets learned to improvise by predicting, whereas the older generation — symbolic systems — learned to prove, not predict. They derive, and operate in the domain of formal logic, where statements are either provably true, provably false, or undecidable. There is no third option involving “sounds about right”.

Here is how symbolic AI works.

You start by defining axioms. Axioms are statements you accept as foundational truths within a domain, and then you define rules that describe valid transformations and relationships between those statements. A symbolic reasoning engine takes those axioms and rules and searches for proofs and if it can derive a conclusion from your axioms using your rules, it asserts the conclusion and if it cannot, it refuses. C’est simple.

This maybe a little confusing at first, but I’m sure that an example will help explain the concept much better.

Think about baking a cake. You start with axioms — the basic facts you know are true. Here are a few

• Axiom 1. I have flour, eggs, butter, and sugar in my kitchen
• Axiom 2. My oven heats to 180°C
• Axiom 3. Cake batter needs to bake for 35 minutes

Then you have rules — the things that must be true for the process to work

• Rule 1. If the oven is broken, I cannot bake
• Rule 2. If I’m missing eggs, I cannot make this recipe
• Rule 3. If I don’t have 35 minutes, the cake won’t be done

A symbolic reasoning engine in this case would be like a very careful baker who checks everything before he’s starting.

He asks “Can I bake a cake right now?”

Then the engine checks

• Flour? Yes. ✓
• Eggs? Yes. ✓
• Oven working? Yes. ✓
• 35 minutes available? Yes. ✓

And because everything checks out, it concludes that “yes, you can bake a cake”.

But when you ask the same question and one egg is missing, the engine concludes it cannot prove you can bake a cake because the eggs axiom is false.

And that is — in retrospect — the usefulness of this class of systems because it doesn’t accept fuzzy situation like “well, maybe you could substitute with applesauce”, it just refuses to conclude something it cannot prove from the facts and rules you gave it.

And that, my friend, is symbolic AI.

See content credentials

Rules replace ‘maybe’ in mission-critical systems

Symbolic AI dominated the practical world long before neural networks became fashionable, and it still runs critical infrastructure you depend on every day. In 1994, Intel was plagued with the now infamous Pentium floating-point bug which cost the company $475 million, after which hardware manufacturers started using theorem provers to mathematically verify that chip designs were correct before fabrication.

And Airbus uses formal verification to prove flight control software won’t kill you and to me it’s a comforting thought they’re not using generative AI for this. And NASA deployed it in spacecraft systems where “oopsy my bad” is not an option. Your compiler checks that your code respects type rules before it runs and in the company you work for, configuration management tools validate that server states satisfy policies and access control systems encode permissions as logical expressions and every time a security framework checks whether you’re allowed to access a file, that’s symbolic reasoning — axioms about roles, rules about permissions — and a proof that derives whether access is granted or denied.

And all these systems share one common property. The cost of a single mistake exceeds the value of ten thousand successes, so they use rules to guarantee correctness instead of statistics to estimate likelihood.

Symbolic AI enjoyed deep adoption in safety-critical industries precisely because it could provide guarantees that statistical methods could not.

And if that sound familiar, you probably work in a regulated enterprise environment.

But these systems have drawbacks. The limitation of purely symbolic systems is that they require exhaustive formalization‡ because very concept must be defined, and every edge case must be encoded. This process is labor-intensive and it’s brittle in dynamic domains and the thing is that human language resists complete enumeration and real world behavior defies tidy axiomatization. So you end up using symbolic AI only when you want to enforce known constraints but you don’t if you want to explore unknown possibility spaces.

And neural networks excel at exactly the opposite problem. They generalize across messy data, and find patterns that humans miss, when something is differs from the template, they can propose creative solutions.

They are ‘exploration engines’ and symbolic systems are constraint engines.

And I want them both for my enterprise AI-based automations, but I don’t want to choose between them. I want to marry them. And that dream has led to this new class of models that’s aptly called ‘Neuro-Symbolic AI’

See content credentials

‡ More on formalization:

• Generative models guess, ontologies clean up the mess | LinkedIn

The neurosymbolic architecture

A neurosymbolic system integrates generative flexibility with formal validation. The architecture looks deceptively simple. You have a large language model generate candidate outputs, and those candidates are translated into formal representations and then, a symbolic reasoning engine evaluates whether the candidates satisfy pre-defined constraints and if validation succeeds, it proceeds with the execution, and if not, the system escalates or it declines.

Amazon Web Services sells this exact capability through their product Bedrock Guardrails, where automated reasoning filters generative outputs against customer-defined policies, and DeepMind’s AlphaProof uses the Lean theorem prover so that mathematical arguments are logically sound before presenting them and legal tech companies like Leibniz AI use formal reasoning to contract interpretation. Government contractors use it to validate compliance with procurement rules. These are all examples of production systems handling billions of dollars in liability.

Symbolic validation is computationally cheap compared to large-scale neural inference with all sorts of engines bolted on top of it. Logical derivations operate over symbolic structures, not high-dimensional tensors. There are no matrix multiplications on GPUs you have to deal with either so the energy profile differs by orders of magnitude and as a result symbolic methods provide high assurance at comparatively low cost. That is, in environments where rules can be defined.

See content credentials

Here is what this looks like in practice.

Say, you have an AI agent managing cloud infrastructure. It proposes scaling resources based on usage patterns, but before executing, the proposal is translated into a formal configuration statement where a validator checks whether that configuration satisfies network isolation requirements and complies with security policies, and if it respects budget constraints. And the change processds when all conditions hold but if any of the constraints are violated, the system halts and it surfaces the conflict for a human to inspect.

The generator explores. The validator enforces. And together they form a feedback loop where creativity is disciplined by proof.

Simply brilliant.

This separation of concerns is born out of necessity. In my AI factory, we cannot deploy agents that guess. Some processes are deterministic by regulatory requirement. For instance, eligibility decisions must reference statutory criteria and financial transfers must satisfy authorization hierarchies in the organization. And also think about the specific rules like Anti-Money Laundering and Know Your Customer:

• Sanction list screening (OFAC, EU sanctions lists) — binary yes/no
• Beneficial ownership verification thresholds (25% ownership = reportable)
• Transaction monitoring rules (e.g., cash transactions >$10K must be reported)
• Politically Exposed Person (PEP) checks

And in healthcare you have HIPAA Compliance that enforce:

• Access control rules (role-based, principle of least privilege)
• Audit log requirements (who accessed what, when — no gaps allowed)
• Breach notification timelines (60 days from discovery, no discretion)
• Minimum necessary standard (must prove access was justified)

And all these domains admit no ambiguity. The rules exist, and they are encoded into the system because execution requires proof of compliance.

Probabilistic systems cannot provide that proof because they operate on likelihood rather than derivation. A language model may generate a decision that mirrors prior cases yet subtly misapplies a clause or it recommends an action that resembles best practices yet it overlooks a context-specific restriction. The error hides in the connective tissue of reasoning but not in the grammar a large language model is renowned for.

This is what I mean by introducing Russian roulette into your process, when you slap an AI onto a process and every autonomous action becomes a gamble, and when the chamber spins, most clicks are empty but eventually the round is live. Organizations that treat this as acceptable risk are being reckless.

Scaffolding revisited

In my earlier writing this week, I described scaffolding as the seven-layer governance and control infrastructure that sits around AI models. Scaffolding determines what models can access, how they interact with tools, what permissions they hold, and crucially, what constraints they must satisfy before acting. It is the difference between an AI system that targets consumers and an AI system embedded in institutional reality.

Neurosymbolic architecture is a manifestation of that scaffolding philosophy that I wrote about. The symbolic validation layer encodes organizational knowledge as executable constraints and transforms policy documents into runtime enforcement or it converts compliance frameworks into deterministic checkpoints.

This is procedural scaffolding made concrete.

But there is also semantic scaffolding which is the layer that grounds language in structured representations of reality. This is where World Models enter the conversation‡. Researchers are building systems that encode objects, relations, and dynamics in latent scene graphs but instead of predicting text about gravity (LLM), these models need to ‘understand’ physics like mass, force, and acceleration. They simulate rather than describe.

This work is important because it addresses the abstraction gap between language and physical reality. A model with internalized physics is less likely to propose impossible trajectories or invent materials that violate thermodynamics. Yet even the most sophisticated world model cannot replace symbolic validation in rule-governed domains. Take gravity for instance, the rules of gravity don’t change (as far as we know) and a latent graph that encodes conservation laws does not automatically enforce procurement thresholds. World models solve one abstraction problem, and symbolic validators solve another but in the end both are necessary. Neither is sufficient alone.

To me, the future of enterprise AI lies in systems that integrate generative exploration, world model grounding, and symbolic constraint enforcement. The generator proposes possibilities across a vast conceptual space, and the Language- or World Model filters for creative or physical plausibility. The symbolic validator ensures institutional admissibility. Only after passing all three layers does execution proceed.

This is engineering.

‡ How World Models work:

• Controllable World Models are here and of course everyone is pretending they always wanted this | LinkedIn
• World Models are the next evolution of AI | LinkedIn

A strategic shift

AI strategy has been measured in parameters and benchmarks for years and this made sense during the capability race when foundational performance improved dramatically year over year, scale was synonymous with progress.

But that era is stabilizing.

You see foundation models converging. The gap between frontier systems is no longer existential for most enterprise use cases. The marginal improvement between version N and version N plus one matters less than the surrounding architecture in which the model operates.

This means that models will become commoditized utilities and that competitive advantage migrates upward into system design. The organization that embeds validation, constraint enforcement, and runtime governance into its AI stack will outperform the organization that plugs in the newest model and hopes for the best.

In other words, scaffolding is the new strategic move. And that’s why I think this should be Europe’s focus (as described in the other article from earlier this week)

The validator in the scaffolding is a strategic asset and it embeds regulatory interpretation or formalizes internal governance and this is a durable layer that survives model upgrades, API shifts, and architectural migrations and without it, strategy remains reactive.

There is also a geopolitical implication here, as I described in the article.

Some regions focus on frontier model development, like the USA, while others focus on applied AI embedded into products and ecosystems like China, but a third strategic path exists, building the most disciplined runtime enforcement layer. As generative models spread globally, the ability to encode and enforce constraints at scale becomes an exportable capability.

AI strategy is no longer about owning the engine alone, but about offering the entire car with the chassis, the brakes, and the instrumentation panel.

Build the reality engine.

Your business depends on it.

Signing off,

Marco

I build AI by day and warn about it by night. I call it job security. Big Tech keeps inflating its promises, and I just bring the pins and clean up the mess.

Think a friend would enjoy this too? Share the newsletter and let them join the conversation. LinkedIn, Google and the AI engines appreciates your likes by making my articles available to more readers.

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI