This is the second of a pair of essays; the first is The Trust Ceiling. It argued that today’s AI is intrinsically untrustworthy, for reasons rooted in what neural networks are. They are statistical approximations, so they carry a permanent error rate; they hallucinate - producing fluent, confident falsehoods - because generating a plausible continuation is precisely what they are built to do; their reasoning cannot be meaningfully explained; and they cannot be even be completely relied on to give the same answer to the same question twice. Traditional symbolic software - programs, algorithms, databases - has the opposite character: deterministic, consistent, explainable and correctable, but unable to touch the messy, unstructured world of language, images and sound that neural networks have conquered. Trillions of dollars of enterprise value sit stuck behind this ‘trust ceiling’, and neither paradigm alone can break through it. The way forward, the first essay argued, is synthesis: neurosymbolic AI that combines neural capability with symbolic trust.
This essay describes in some detail how that synthesis can be delivered - and why the version of it that the industry is quietly converging on falls short.
What the industry does now
Mainstream AI already leans on deterministic machinery wherever an answer has to be exactly right rather than merely plausible, and where it does this is revealing. The pattern shows up in three now-standard places, and in all three the deterministic part is bolted onto the statistical model rather than fused with it.
The clearest is tool use. Modern LLMs are given calculators, currency converters, search APIs, and database connectors, and trained to call them. When a model needs an exact sum or a live figure it no longer computes from its weights; it emits a structured call and a deterministic backend returns the value. This is a tacit admission that the statistical core cannot be trusted with precision. But each tool is pre-written by engineers and does one narrow, fixed thing. They are islands of reliability drawn from a finite library, and the breadth needed to handle real work comes not from the tools but from the model deciding which to invoke, with what arguments, in what order, and what to do with the result. The reliable parts are narrow; the general capability knitting them together is wholly statistical.
A related move offloads reasoning into code: rather than reason “in its head”, the model writes a short program and an interpreter runs it. Execution is perfectly deterministic, so if the code and input data is correct the answer is correct. The catch is the “if”. LLMs writing correct code is itself a statistical act, and code is a general computational artifact, able to express arbitrary, unbounded computation. In general there is no way to certify that an arbitrary program is correct, or even that it will finish running. Testing helps but does not close the gap - a test suite samples behaviour rather than proving it, and here the program is new with every query, so no suite accumulates. What remains is review and debugging, which is to say human engineers in the loop. The interpreter faithfully executes whatever it is handed and gives no assurance that what it was handed is right. Automating the writing while still depending on engineers to make it trustworthy does not remove the human, it relocates them.
The same logic drives retrieval-augmented generation (RAG) against structured sources. Instead of recalling facts from weights in the neural model, where they blur and drift, systems query databases or knowledge graphs and try to ground their output in the records returned, usually by translating the question into SQL or a graph query. The retrieved rows are exact. Yet the model still writes the query (text-to-SQL is notoriously error-prone), the choice of what to ask for and where is itself a statistical judgment, and the model still reads the results and phrases the answer, where it can (and does) hallucinate over perfectly good data.
Across all three, the deterministic turn is real and revealing, but it stops short. The reliability is sealed inside the tool: the interpreter runs faithfully, the database returns exact rows, the calculator adds correctly. The reasoning that strings the tools together, choosing to call, choosing which database, framing arguments, composing the query, reading the result, is the same statistical, best-guess process described in the first essay. The fault from a trust point of view is not that a neural network is involved but where it sits and whether anything checks its output: it is in control of every step, so each step is a fresh guess that nothing verifies. These systems are therefore chains of guesses, and probabilities of being wrong accumulate down the chain. As the first essay argued, at scale even a tiny error rate becomes a torrent of bad results. A run of near-perfect neural decisions wrapped around perfectly deterministic tools is, as a whole, still a probabilistic system, and inherits the untrustworthiness the tools were brought in to remove.
The industry knows this, and answers with the agentic toolkit: verification steps, self-consistency checks, retries, guardrails, human review at the seams. These help, and the gains are real, but notice what each of them is. A guardrail that is a hard rule is itself symbolic machinery, another quiet admission of the thesis of this essay, yet it catches only the failures someone anticipated. A verifier that is another LLM is more guessing checking the first. A human in the loop reintroduces the human the system was meant to replace. In every case error is reduced, not eliminated, and reduced at steep cost in time, tokens, and money: every layer of checking multiplies the work done per query, and what the multiple buys is a lower error rate, never a guarantee. That cost is central, not incidental: the AGI prize is “...most economically valuable work”, and a method that drives its error toward, but never to, zero by spending ever more compute on layers of checking is a poor foundation for automating the world’s economy.
The strongest objection to this whole line of argument deserves stating at full strength: the models keep getting better. Scaling, test-time compute and self-verification have delivered results that looked impossible before they happened. In 2025, general-purpose models reasoning in plain natural language achieved gold-medal performance on International Mathematical Olympiad problems. If capability keeps improving, is there a possibility that the error rate simply falls below a level anyone cares about?
Perhaps. But for serious work the question is not only how often a system is wrong; it is whether anyone can tell when it is. Mathematics shows the difference, because mathematics is where checking exists. Those gold-medal solutions were written in prose, and they count as gold only because independent expert examiners verified every line after the fact: correctness was established by the checking, not by the machine that produced the answers. That is exactly the labour the trust ceiling describes, and no business can attach a human examiner to every answer. Contrast an earlier landmark from the same lab. DeepMind’s AlphaGeometry performs at the level of an olympiad gold medallist in geometry by pairing a neural model with a symbolic engine: the neural side proposes constructions, but every step of the proof itself is derived by the symbolic side, so producing an invalid proof is not something the system can do. When it fails, it fails by finding nothing, never by asserting something false. That is the difference in kind. A natural-language system that reasons correctly more often is still a system whose every answer must be checked by an expert; a symbolic derivation can be checked mechanically, step by rule-bound step, by anyone - and it comes from a machine that could not break the rules in the first place. DeepMind itself, announcing its gold medal, said its formal, verified systems remain part of the path forward. Capability progress raises the ceiling on what neural models can attempt; it does not change the kind of machine attempting it. Where the answer must be certain, the field’s own strongest results already separate the guesser from the guarantor.
A stronger way forward
So the AI industry has identified places where it needs certainty and dropped deterministic machinery into those spots - some repurposed, some now purpose-built - while leaving the model in the control seat: summoning trustworthy components through an untrustworthy process, and falling back on that process for everything its finite tools cannot cover. The reasoning itself was never made symbolic.
Durably closing this gap is not a matter of a better guesser steering the same architecture, nor of wrapping it in more verification. It calls for the opposite arrangement: the neural network at the edges, doing what only it can do, and deterministic reasoning over structured representations of meaning at the core, so that trust lives in how the system reasons rather than in a library of pre-written tools it happens to call.
Where exactly does the dividing line fall? What stays neural is what neural networks are unmatched at: perception, fluent communication, and turning messy, unstructured reality into structure. What moves symbolic is anything whose output must be exact, repeatable or explained: applying rules, combining facts, reaching decisions, retrieving knowledge, checking compliance. The line is not always sharp, and it does not need to be: what matters is that the trust-critical side of it is symbolic.
The industry has not so much discovered and refined this pattern as begun to back into it. The instinct to pull work toward something checkable, to ground a model’s output rather than trust it raw, surfaces in more and more systems. But in mainstream practice the move stays incidental and shallow: a patch in front of a system whose reasoning remains statistical and whose control still rests with the neural model. The instinct is right; the commitment is missing. A field’s intuitions are formed by what has rewarded it, and scaling neural networks has rewarded this one richly; the natural inclination of a discipline is toward the approach that built it. That gravity is reinforced by where capital, talent and prestige now sit, all concentrated on the same bet. The argument here is not to take the foot off the gas with deep learning; the capabilities are indispensable and should be pushed to their maximum. It is that deterministic, symbolic, semantic methods, in synergy, deserve a commitment of similar order.
UnlikelyAI has been pursuing this deliberately for many years. We began before ChatGPT, post-transformer but pre-LLM, working from the conviction that advances in neural capability had, for the first time, made trustworthy AI possible at scale: by enabling the moving of problems out of the statistical domain and into the symbolic one. That conviction has been the company’s focus ever since, and the work has produced a large body of core AI patents covering methods for making AI and LLMs trustworthy, together with commercial implementations. None of this is a blank sheet or a research programme in waiting: the pattern described next is delivering results in commercial applications today, in the domains where correctness carries a price, and explanation has economic value: accountancy, finance, insurance, regulation, enterprise knowledge. A great deal can be built, and trusted, before the full vision is delivered, and every step of the path pays its own way.
The pattern at the heart of this is to move a problem out of the world where only neural methods can operate and into one where symbolic methods can be effective. Instead of asking a neural model to solve a task directly, we first transform the task. Complex, unstructured data is ingested and converted into a structured representation that captures its meaning: a semantic artifact. Once the problem is in this form, deterministic methods reason using the artifact to produce results that are accurate, consistent, and explainable. In these situations the neural network does what it is unmatched at, understanding complex data, and then steps aside; the reasoning, the decision, and the explanation, the parts that demand trust, are directed by machinery that can provide it. The complex data can be images, voice, or video, but most importantly it is natural language: descriptions of policy and rules, knowledge held in documents, transcripts, emails, web pages.
We call this pattern STRIDE (Semantic TRanslation Into Deterministic Execution).
The STRIDE process relocates trust, but it raises an obvious objection: the ingestion step is itself neural, so does it not simply reintroduce the unreliability we were trying to escape? Ingestion is exposed to neural error, but the situation differs from broad neural processing in two decisive ways.
The first is economic. Ingestion happens once, while results are typically generated from the artifacts many times. A piece of regulation can be turned into symbolic form once and then applied millions of times across a regulated industry; a consumer insurance policy might be ingested once and have tens of thousands of claims evaluated against it before it changes; enterprise knowledge ingested once may answer thousands of employee questions. Because the cost of ingestion is paid once and amortised over every later use, a great deal of effort can be spent validating it, maybe offline and maybe without time pressure, before the artifact is trusted. The careful checking that would be ruinous to repeat on every query in an agentic system is, here, a one-time investment. This consideration points at where this pattern best applies, and it is a revealing one: it fits best wherever knowledge outlives the queries made against it - policies, regulation, enterprise knowledge, product truth - which is precisely where the trust ceiling blocks the most value.
The second difference is that semantic artifacts are checkable in a way generated code is not. Code can express any computation whatsoever, which is precisely what makes it exceptionally hard to check in general. A semantic artifact is the opposite: a deliberately constrained form, whose structure and symbols correspond directly to structure and meaning in the source data, so the mapping can be validated against the original, by automated checks and by test examples. The initial mapping is subject to neural error, but that error can be caught and corrected at rest, before any reasoning depends on it.
A residue of neural risk can also remain at the moment of use: translating the user’s question into symbolic form, if needed, is a statistical act, and for some types of artifact neural models may be used in limited ways within a case. But these acts, if present, differ in kind from the guesswork of an agentic chain. Each is narrow and well-defined, a bounded question posed by the symbolic machinery rather than a decision about what to do next; each is permitted to return don’t-know, an answer the machinery accepts and acts on rather than papering over; and each is individually visible in the reasoning trace, where a wrong answer sits as a named, contestable fact rather than a silent redirection of everything downstream. An agentic system produces a trace too, and the trace can be read. The difference is what the trace determines. When an agent writes ‘let me check the database’, nothing fixes what it will actually query, or whether the next step follows from this one; in a symbolic system, each step determines the next. A symbolic trace is not a narration of the reasoning. It is the reasoning. The control flow - which questions matter, how the answers combine, what follows - is not in neural hands. Neural error does not vanish entirely; rather neural acts are limited, checkable and stripped of the power to steer, so error, if it lands, lands where it can be seen instead of compounding where it cannot.
Semantic artifacts come in different kinds, suited to different data and different tasks, and more than one kind can be generated from the same source. One example is a Policy Tree, which captures and symbolically represents the logical structure of the rules buried in policy and regulatory documents. Ask an LLM directly whether an insurance claim is covered and our experiments showed error across every model, with answers sometimes reflecting what the model expects a policy to cover rather than what it says, and the same claim even yielding different verdicts on successive tries. Rendered as a Policy Tree and reasoned over symbolically, the same question is answered precisely, consistently, and with an explanation citing the clauses relied on. The leaf facts themselves may be resolved symbolically or with the help of neural models, and in the latter case those judgments can be wrong - the residue of neural risk described above. But something important has changed. The reasoning is now guaranteed: given the facts, the verdict follows from the policy’s actual logic, every time. And the possible error sites are no longer everywhere and nowhere; they are an enumerable list of named, bounded questions, each able to answer ‘unknown’, each visible in the explanation, each individually checkable and escalatable where the stakes require it. How much interpretation is resolved at ingestion and built into the tree, and how much is left as a bounded question at a leaf, is itself a design choice: a dial, and each turn toward ingestion moves judgment to where it is validated once, at rest, instead of exercised fresh on every case.
A second illustrative and very different example we call a Context Free Response: a small, self-contained unit of natural language whose meaning is true and complete on its own, independent of any surrounding conversation. ‘Yes, that is true‘ is not context-free, since its meaning is set entirely by what came before; ‘UnlikelyAI’s parental leave policy applies to all full time employees with at least one year’s continuous service‘ is. Because it is validated in advance and at runtime selected and then reproduced rather than generated, there is a complete guarantee against hallucination. The only possible failure case is an answer that isn’t responsive to the question.
Policy Trees and Context Free Responses are two instances of the STRIDE pattern that extends across many domains and many more artifact types. STRIDE can be applied wherever natural language encodes rules, knowledge, or other content whose meaning matters: regulatory compliance graphs that monitor live conversations against financial regulation; semantic representations of job specifications and candidates that allow matching by inference rather than keyword; symbolically indexed retrieval over regulated document sets. The particular artifact type varies with the domain; the pattern - neural ingestion, symbolic processing, trustworthy results - is always the same.
A Symbolic Language for Everything
These artifacts in STRIDE capture the meaning of particular kinds of data: a policy, a rule, a self-contained fact. That invites the question the rest of this essay turns on. If meaning can be made symbolic for a policy or a fact, how far can it go? What if the world had a single symbolic representation at least as expressive as natural language itself: able to encode the meaning of any document or conversation, and whatever an image, a recording or a stream of sensor readings can be said to contain, shared by everyone, so that anything that can be described in human language could be retrieved and reasoned over in the symbolic domain?
UnlikelyAI has a concrete vision for exactly such a representation. We call it UL, for Universal Language. This is no mere thought experiment: it has a defined syntax, methods for building it systematically, and a reasoning engine built and operated at scale, developed over years. Delivering the full vision will take substantial further investment - the work so far proved the foundations rather than finished the building - and the design tries to confront hard problems, from grounding the meaning of symbols, to keeping symbolic reasoning tractable at scale, to translating reliably between natural language and symbolic form, that earlier pure symbolic knowledge projects, from Cyc to the Semantic Web, never solved. Those previous efforts had to be built by hand, symbol by symbol and rule by rule, by skilled engineers working for decades, and the sheer scale of human knowledge outran them all. Something fundamental has changed since: the translation that once had to be done by hand and thus never at scale is exactly what LLMs have now made possible, which is why this vision is achievable today in a way it never was before. The UL design is precise enough to say what it makes possible, to show how these problems can be addressed, and to argue that something like it is what trustworthy AI at scale will ultimately require. What it buys is set out below: a memory for AI that is unlimited in size, always current, and shared; retrieval that is exact and complete rather than approximate; and reasoning in which every step is correct, visible, and on the record.
Knowledge today is scattered across incompatible representations: this database’s schema, that document’s prose, this model’s weights, each a private dialect that does not compose with the others. Two systems that both know something about the same entity will struggle to recognise that they are talking about the same thing. The foundation of Universal Language is a vocabulary of global symbols that dissolves this barrier: identifiers whose meaning is the same wherever they appear, so that a symbol for the River Thames, the profession of piano tuning, the colour green, the class of spoon-shaped objects, the relationship of being a supplier to, the act of loaning money, the legal concept of negligence or the emotion of homesickness means that thing, and only that thing, in every document, every database and every system that uses it. Meaning attaches to the symbol through the knowledge recorded about it, not in the words that happen to surround it. Combinations of symbols describe, uniquely and unambiguously, all meaning. When a symbol means the same thing everywhere, anything anyone records about it enters a common body of knowledge that everyone else can draw on. Knowledge stops being a collection of disconnected islands and becomes additive: each new fact, each new rule, slots into the same shared structure and is immediately available to every system that speaks the language. And because the structure is shared, it never stops growing and stays current: every conversation, document, and observation processed anywhere can leave permanent knowledge behind, a genuine form of continuous learning with no retraining cycle and no knowledge cutoff.
This is why the meaning is genuinely universal. Machines exchanging Universal Language exchange meaning directly, with no ambiguity to negotiate and nothing lost in translation. More important still is what every fact can carry: its sources. Knowledge gains something it almost never has today: provenance at the level of meaning. When two sources disagree, the disagreement is visible, because both refer to the same underlying thing rather than a collection of similar-looking strings. Knowledge ceases to be a haystack of text and becomes a structure with attribution, in which the trustworthy and the doubtful can be told apart.
This is also where the neurosymbolic vision connects to the direction the broader field is moving. A wave of heavily funded new ventures has formed around the conviction that world models - AI systems that maintain an internal model of how the world works and can reason about cause and effect rather than pattern-complete from text - are the necessary next step. In the past year, some of the field’s most prominent researchers have raised billions on this conviction before shipping a product. These programmes would not describe their goal as symbolic, and some have argued explicitly against symbolic methods. The shared ground is narrower but real: token prediction over text is not enough, and intelligence needs some model of what the text is about.
Where every one of these programmes stops short is what happens to that meaning afterwards. Whatever a world model or a language model learns stays locked inside the system that learned it, unreadable by the people it affects and unusable by any other system. (Language models show the knowledge is there: we have extracted common-sense knowledge automatically from LLMs and rendered it in symbolic form.) What makes human knowledge powerful is not simply that it is abstract but that it is named and shared: financial advice means the same thing to a regulator, a banker and a consumer because they share a language grounding it in a common world. Named global symbols do the same work for machines, and a shared store of them has much of what this camp is reaching for in a world model - persistent, stable, continuously updatable - with one property no private representation can offer: it can be read, by the people the knowledge affects and by every system that speaks the language.
Reasoning you can see
A shared symbolic language changes reasoning as profoundly as it changes knowledge. Because knowledge can be expressed as symbols, the rules that operate on it can be written in the very same form: a rule is just another statement in the language, stored alongside the knowledge it reasons over, carrying its own source and subject to the same scrutiny. Reasoning is no longer partially hidden inside the weights of a model; it is completely composed of inspectable parts.
The consequence is explanation of a kind neural systems cannot offer. When a system reasons over Universal Language, every step is a symbolic statement, and the whole chain from question to conclusion can be laid out and read back: the rule that was applied, the facts that satisfied it, the sources those facts came from, and how trustworthy each was. This is not a story generated after the fact by a model trained to sound convincing, nor the terse verdict that earlier symbolic systems typically offered in place of their working. It is a faithful record of what the system actually did, because the record is the reasoning. Explainability stops being a hope and becomes a property of the architecture.
This is also where trust becomes something you can build rather than wish for. The rules that govern what an AI system may or must do can be written in the same language as the facts they constrain and the reasoning they direct. A constraint becomes an inspectable, debatable artifact: it can be read by a person, challenged, amended, version-controlled, and audited, and a system can be required to demonstrate, in a chain anyone can check, that what it proposes to do complies with the rules in force. Safety stops being an emergent property of an inscrutable model and becomes a matter of written rules and checkable compliance, the way every other system humanity trusts with serious consequences already works.
Retrieval that finds the answer, not something like it
The difference between this and today’s dominant approach is sharpest in how knowledge is retrieved. Retrieval-augmented generation (RAG), the standard way of grounding a language model in a body of knowledge, works by estimating relevance: a question is turned into a numeric vector, the passages closest to it in that space are pulled in, in modern systems blended with keyword matching and re-ranking, and the model stitches them into an answer. It is ingenious and it is everywhere, but every ingredient in the blend does the same kind of work, scoring passages by how much they resemble the question, and its weaknesses are built into that work. The passage that best resembles the question is not always the one that holds the answer. A snippet arrives stripped of the context that qualified it. And a model asked a question it cannot answer is built to produce something rather than nothing, which is to say, to hallucinate.
Retrieval over Universal Language works by meaning, not by proximity. A question becomes a structured query with explicit unknowns, and the system searches the body of knowledge by the structure of meaning itself: matching knowledge containing passages of UL directly, applying rules whose conclusions fit the question, letting reasoning reach knowledge semantically distant from anything the query mentions and running computations where a value must be derived. If the knowledge is present, it is found and complete, because the search is exact rather than approximate. If reaching it needs several facts combined through reasoning, they are combined, and the rule used is itself on the record. And if the answer cannot be derived, the system can say so, returning don’t know rather than a confident fabrication. This is an architectural guarantee, rather than a cautious design choice. When the knowledge needed to answer a question is not in the store, there is no mechanism by which anything incorrect can be generated. In a symbolic reasoner, hallucination is not a code path. Approximate recall of compressed text on one side; exact retrieval of structured meaning on the other.
The economics of knowledge update are different too. A language model’s knowledge is fixed at the point its training data was collected; absorbing new knowledge requires retraining, a process that takes months and costs millions. Knowledge in a symbolic store is different in kind: a document translated into symbolic form today is queryable today, by every system that draws on that store. There is no retraining cycle and no knowledge cutoff. Knowledge that changes or is augmented is corrected or augmented once in the store and immediately correct everywhere. This is continuous learning in the most literal sense: the substrate is continuously current in a way no model trained on a snapshot of the world can be.
Beyond text
Universal Language would be a narrower idea if it reached only documents. The same representation can absorb other kinds of data. A vision system can describe what it sees directly as symbolic meaning; speech can be rendered as structured attributes; a stream of sensor readings can be projected into the same form the moment it arrives. Once any of this has been ingested, it sits in the same shared store as everything else and is reasoned over by the same machinery.
This is the most ambitious form of the pattern that runs through the whole of this essay. A Policy Tree encodes the meaning of a policy; Universal Language would encode the meaning of, in principle, anything that can be perceived or written down. The neural systems that do the ingesting remain indispensable, because translating language, describing images, and interpreting sound is exactly what statistical models are good at. But their output is dropped into a representation that is shared, additive, and auditable. The perception is neural; the substrate is symbolic; trust attaches to the representation, not to the perceiver.
Coda
A shared symbolic substrate would change what AI is. Knowledge would no longer be trapped inside any one model and would become global infrastructure: continuously updated, attributable, debatable, and additive across providers and across human languages. AI systems would explain themselves not as a performance after the fact but as a consequence of how they reason. The rules that constrain their behaviour would be written down, in the same language as the facts they govern, where anyone could inspect them.
The dominant bet of this moment is on ever more expensive neural models: more parameters, more data, more compute. That bet has produced extraordinary capabilities and will produce more. But trustworthiness, on the evidence so far, is not what it pays out on; the failure modes of the largest models are the failure modes of the smaller ones, scaled up. The neurosymbolic alternative is to spend the coming years building, alongside and in synergy with the models, a substrate they can stand on: one in which meaning is shared, knowledge is structured, reasoning can be seen, and rules are written down. Universal Language is a concrete proposal for what that substrate could be.
And the journey from here to there is not a leap. The path from the semantic artifacts working today to a full symbolic substrate is continuous: a Policy Tree can incorporate shared symbols; the retrieval layer already runs on global identifiers, the first piece of the substrate in working form; each new artifact type moves more of the work into the domain where it can be checked. Trust increases with every step, and every step delivers value on its own. The substrate is not a precondition for trustworthy AI; it is where trustworthy AI, built piece by piece, is heading.
Its appeal, in the end, is not merely technical but civic: trustworthy AI will require a symbolic substrate of meaning, and such a substrate is something humanity has to build.
I like the concept of a repository of Universal Language that is continuously added to and updated establishing a more objective framework for retrieval than a strictly best guess based neural network. Where I get hung up is on how the meaning piece gets settled. Meaning is often subjective and the view of a given observer is informed by vastly different worldviews. For example, the top down mandate in China to protect the party at all costs will yield a much different meaning of the concept of freedom than that of an observer in the US which will likely differ from that of an observer from the EU. Instead of a Universal Language, it begins to look like a collection of competing interpretation of meanings from differing points of worldview.
Thanks for this important, leading-edge work and thinking.