Why symbolic AI failed for forty years, and why LLMs just fixed it
Symbolic AI's inspectable, provable knowledge was always the right idea. It failed commercially because hand-building it cost more than it returned. Large language models just made that acquisition cost collapse, which is why the symbolic half is worth pairing with them now.
Symbolic AI is the field's longest-running disappointment, and one of its best ideas. For roughly forty years, from the expert systems of the 1980s through the enterprise ontology projects that followed, the same promise kept being made and the same failure kept arriving. The interesting part is why it failed. It wasn't the concept. It was the economics. And the economics just changed.
The promise
The promise of symbolic AI was knowledge you could trust mechanically: facts represented explicitly, so a system could inspect them, query them, and prove how it reached a conclusion. An expert system didn't guess. It followed rules you could read. An ontology didn't vibe. It encoded what your organisation actually meant by "customer" or "incident" or "approved supplier". The enterprise knowledge projects that followed carried the same ambition: a structured memory of the business that software could traverse and prove things about.
For any organisation that has to defend its decisions, to a regulator, a court, an auditor, this is exactly the property you want. Inspectable. Queryable. Provable.
The bottleneck
The failure mode was just as consistent as the promise. Every fact in those systems had to be put there by a person. Domain experts sat with knowledge engineers and hand-authored rules, taxonomies, and relationships, slowly, expensively, and forever, because the business kept changing underneath them.
The field had a name for this: the knowledge-acquisition bottleneck. It killed projects with brutal regularity, not because the encoded knowledge was wrong, but because keeping it current cost more than the system returned. Expert systems didn't die of bad reasoning. They died of maintenance. The symbolic approach lost every commercial argument to the same line item: the cost of building and tending the knowledge by hand.
What changed
Large language models changed the cost structure, not the goal. An LLM can read an unstructured policy document, a contract, a procedure manual, and propose the structure that a knowledge engineer used to extract by interview. Entities, relationships, versions, contradictions between documents: the model drafts them automatically, at the speed of reading rather than the speed of workshops.
That is the historic shift. The expensive half of symbolic AI, acquisition, collapsed in cost. The bottleneck that defined four decades of failure dissolved, not because anyone solved it directly, but because a different technology made it irrelevant.
Why you still need the symbolic half
It's tempting to conclude that LLMs make explicit knowledge unnecessary, just ask the model. But the model alone cannot do the things the symbolic tradition was right about.
An LLM cannot reliably tell you which of two contradictory policies is the current one; it will fluently answer from either. It cannot prove where an answer came from; it can only generate something citation-shaped. And it cannot enforce who is allowed to know what; a model that has read everything will, on the wrong prompt, repeat anything. Inspectability, provenance, and permission are structural properties. You don't get them from better prompting. You get them from explicit, governed knowledge: the symbolic half.
The synthesis
The systems worth building now pair the two halves: models that read everything, and a governed memory that holds them to what's true. The LLM does the work that bankrupted the expert-systems era: reading, extracting, proposing structure. The memory does the work LLMs can't: versioning the knowledge, detecting its contradictions, recording its provenance, enforcing its permissions.
This isn't a replacement for the AI tools an organisation has already adopted. It's the layer underneath them, the thing that lets you trust what they answer from. Symbolic AI didn't lose the argument. It lost the bill. The bill just got paid by the other side.
Loriq builds SAGE, the governed memory engine. Talk to us.