Definition
Symbolic AI is the approach that builds intelligence out of explicit, human-readable symbols and hand-written rules of logic: a person writes down the knowledge as facts and if-then rules, and the machine draws conclusions by manipulating those symbols. This is the exact opposite of today's dominant method, a neural network that learns its behaviour from data. The contrast is the whole point of the term. In symbolic AI a human writes the rule if the patient has a fever and a stiff neck, suspect meningitis; in a neural approach nobody writes that rule, and the network instead infers the pattern from thousands of labelled patient records.
Because a person writes the rules, symbolic AI is often called classical AI, or GOFAI, for "Good Old-Fashioned AI", a label the philosopher John Haugeland gave it in 1985. It was the mainstream paradigm of the field from the 1950s through the 1980s. It matters now because the pendulum has swung back: after a decade in which learning-from-data won almost everything, researchers are combining the two, bolting a symbolic reasoning engine onto a neural network to recover the reliability and transparency that pure neural systems lack. Understanding what symbolic AI does well, and where it breaks, is what makes that revival make sense.
How It Works
A symbolic system has two parts that stay strictly separate: a knowledge base and an inference engine. The knowledge base is the content, a collection of facts (socrates is a man) and rules (if X is a man then X is mortal), all written in a formal notation a human can read and an expert can audit. The inference engine is the machinery, a general-purpose procedure that applies the rules to the facts to derive new facts. The same engine can run a medical knowledge base or a chemistry one; you change the system's behaviour by editing the rules, not by retraining anything.
The engine reasons in one of two directions. Forward chaining starts from the facts you have and fires every rule whose conditions are met, adding the conclusions as new facts, repeating until nothing new can be derived. Backward chaining starts from a goal you want to prove and works backwards, asking what would have to be true to establish it, which is how a diagnostic system decides which question to ask next. Underneath both sits unification, the pattern-matching step that binds a variable like X to a concrete value like socrates so a general rule can apply to a specific case.
The defining property that falls out of this design is transparency. Every conclusion is the end of a chain of rules, so the system can always answer "why?" by replaying the exact rules it fired. That is a guarantee a neural network cannot give: it produces an answer but no human-readable derivation. The flip side is equally structural. A symbolic system knows only what its rules say. Present it with a situation no rule covers and it does not degrade gracefully or make a reasonable guess, it simply has no applicable rule and stops. It is provably correct within its rules and blind outside them.
Real-World Applications
The founding demonstration was the Logic Theorist, written by Allen Newell, Herbert Simon, and Cliff Shaw and running in 1956. It was a program that proved mathematical theorems by searching for chains of logical inference, and it re-proved 38 of the first 52 theorems in Chapter 2 of Whitehead and Russell's Principia Mathematica. For one theorem, 2.85, it found a proof shorter than the humans' original, a result Simon reportedly showed to Russell himself. Its successor, the General Problem Solver (Newell and Simon, 1957), tried to generalise the same search-based reasoning to any problem stated in symbolic form.
The paradigm's commercial peak was the expert system, a knowledge base of if-then rules capturing a specialist's know-how. The canonical example is MYCIN, built at Stanford in the early 1970s to diagnose bacterial blood infections and meningitis and recommend antibiotics. It reasoned over a few hundred hand-written rules and, in evaluation, matched or beat human specialists, yet was never deployed clinically. DENDRAL, started at Stanford in 1965, identified organic molecules from mass-spectrometry data and was the system that first showed encoded expert knowledge could outperform general-purpose search.
Symbolic methods are far from extinct. Wolfram Alpha answers questions by symbolic computation over curated mathematical and scientific knowledge rather than by prediction. Cyc is a decades-long project to hand-encode commonsense knowledge as millions of logical assertions. Theorem provers, constraint solvers, planners, and knowledge graphs are all squarely symbolic. The most active frontier is neuro-symbolic AI, which pairs a neural network's perception with a symbolic engine's rigour: DeepMind's AlphaGeometry couples a language model to a symbolic deduction engine to solve olympiad geometry problems, and AlphaProof pairs a model with the Lean theorem prover so that every step it produces is formally checked.
Key Concepts
The single idea that explains both the triumph and the collapse of symbolic AI is that knowledge is written, not learned. Everything the system can do comes from rules a person put there. That gives you transparency (you can read the rules), correctness (the engine only draws valid conclusions), and editability (fix a rule, fix the behaviour). It also gives you the bill: someone has to write, validate, and maintain every one of those rules by hand.
The counterpart concept is brittleness. A learned model interpolates: shown something slightly off its training data, it still produces a plausible answer, sometimes wrong but rarely absent. A rule-based system does not interpolate. Just outside the boundary of its rules its competence drops to zero rather than degrading gently. This is why symbolic and neural AI are so often described as complementary: one is transparent but brittle, the other robust but opaque, and each is strong exactly where the other is weak.
Challenges
The failure that ended the expert-system era has a name: the knowledge-acquisition bottleneck. Every rule had to be extracted from a human expert and hand-encoded, and real domains are enormous. Suppose a serious diagnostic system needs on the order of 10,000 rules, and eliciting, encoding, and validating each one costs an expert roughly an hour of careful work. That is about 10,000 hours, close to five person-years of specialist time, before the system covers its field, and the knowledge keeps changing underneath you. This did not scale, the systems proved costly and fragile, and the market for them collapsed in the late 1980s, a central episode of the AI winter.
The second wall is combinatorial explosion. Reasoning by search means exploring a tree of possibilities, and that tree grows exponentially. A problem with roughly 10 choices at each step and a solution 20 steps deep hides its answer among about 10 to the 20th states, an unsearchable number no faster computer meaningfully dents. Symbolic systems tame this only by adding more expert rules to prune the search, which feeds straight back into the acquisition bottleneck.
Deepest of all is the frame problem and the commonsense knowledge it exposes. The world has effectively unlimited unstated exceptions. A rule says birds fly; then you must add that penguins do not, and injured birds do not, and birds in a sealed box do not, and so on without end. Writing explicit rules for a domain whose exceptions never stop is the thing symbolic AI fundamentally cannot do, and it is precisely the messy, open-ended competence that learning from data handles well. That mismatch, not any single technical limit, is why the field's centre of gravity moved to neural methods.
Future Trends
The clearest direction is the neuro-symbolic revival already visible in AlphaGeometry and AlphaProof: use a neural network for the perception and intuition that rules cannot capture, and a symbolic engine for the steps that must be exact and auditable. The motivation is sharpened by the weaknesses of large language models, which are fluent but hallucinate and cannot show a checkable derivation, exactly the guarantees symbolic reasoning was always able to give. A neural front end that proposes, checked by a symbolic back end that verifies, is a way to get plausibility and provable correctness at once. Related pushes include grounding causal reasoning and formal verification in symbolic structure, and using machine learning to help populate the knowledge representation that hand-encoding could never fill fast enough.
Code Example
Forward chaining is the whole idea of symbolic AI in a few lines: explicit facts, explicit rules, and an engine that repeatedly fires any rule whose conditions are all satisfied until no new fact appears. This toy diagnostic engine, in the spirit of MYCIN, derives a treatment from symptoms, and, unlike a neural network, it can name every rule it used to get there.
facts = {"fever", "stiff_neck", "csf_bacteria"}
rules = [
(["fever", "stiff_neck"], "meningitis_suspected"),
(["meningitis_suspected", "csf_bacteria"], "bacterial_meningitis"),
(["bacterial_meningitis"], "give_ceftriaxone"),
]
added = True
while added: # forward-chain to a fixpoint
added = False
for conditions, conclusion in rules:
if all(c in facts for c in conditions) and conclusion not in facts:
facts.add(conclusion)
print(f"fired: {' + '.join(conditions)} => {conclusion}")
added = True
print("conclusion:", "give_ceftriaxone" in facts)
Running it prints the exact chain of reasoning:
fired: fever + stiff_neck => meningitis_suspected
fired: meningitis_suspected + csf_bacteria => bacterial_meningitis
fired: bacterial_meningitis => give_ceftriaxone
conclusion: True
The strengths and the fatal weakness are both on display. The recommendation is fully explainable: three named rules, each traceable to a human author. But remove the csf_bacteria fact, or feed it a viral infection nobody wrote a rule for, and the engine returns nothing at all, not a hedged guess. Scale that gap to every exception in real medicine and you have the knowledge-acquisition bottleneck in miniature.