The History of AI, Part 7 of 24. The first AI winter left the field chastened. Part 6 ended with researchers quietly retreating from grand ambitions. This chapter is about what they did next: they traded general intelligence for specialized knowledge, built "expert systems" that earned real money, and set off the first AI boom to reach the business world.

Imagine you are an AI researcher in 1974. Your funding is shrinking. The big promises (talking robots, universal problem solvers, flawless translators) have not come true. Colleagues are quietly relabeling their work as "informatics" and "knowledge engineering" to dodge the stigma. What do you do?

One answer, which turned out to be spectacularly productive, was to lower your sights and raise your results. Stop trying to build a machine that is generally smart. Instead, build a machine that is very knowledgeable about one narrow thing, and make it good enough that someone will pay for it.

That shift, from general problem-solvers to specialized expert systems, defined AI for the next fifteen years. It produced the field's first genuine commercial successes, an industry worth billions, magazine covers, and a global arms race over "fifth generation" computers. It also set up the second and more brutal winter that we'll cover in Part 8.

Let's see how it happened.

The big idea: knowledge is power

The intellectual father of this movement was Edward Feigenbaum (1936-), a Stanford computer scientist who had studied under Herbert Simon at Carnegie Tech. Feigenbaum looked at the first two decades of AI research and drew a pointed conclusion.

Edward Feigenbaum, who championed knowledge-based expert systems
Edward Feigenbaum, who championed knowledge-based expert systems. Image: orcmid, CC BY 2.0, via Wikimedia Commons.

The early programs, he argued, had tried to be smart through clever general reasoning methods: search, heuristics, means-ends analysis. But when he watched human experts at work, he noticed something different. A doctor, a chemist, or a geologist isn't impressive because they have a superior general reasoning algorithm. They're impressive because they know a great deal about their field: thousands of facts, rules of thumb, exceptions, and patterns built up over years of experience.

Feigenbaum summarized this as the Knowledge Principle: a system exhibits intelligent behavior primarily because of the specific knowledge it contains about its task domain, not because of the cleverness of its reasoning method. Or, in the slogan that went around Stanford, "Knowledge is power."

That implied a practical program. If you want a machine to perform like an expert, don't wait for a general theory of intelligence. Sit down with the expert, extract what they know, encode it in a form the machine can use, and combine it with a fairly simple reasoning engine. The knowledge does the heavy lifting.

DENDRAL: the prototype

The first system to prove the point was DENDRAL, begun in 1965 at Stanford. The team combined Feigenbaum with the geneticist and Nobel laureate Joshua Lederberg, the computer scientist Bruce Buchanan, and the organic chemist Carl Djerassi (famous for his work on the birth control pill).

The problem: when a chemist analyzes an unknown organic compound with a mass spectrometer, the instrument produces a spectrum, a pattern of peaks corresponding to fragments of the molecule. Working out the molecular structure from that spectrum is a puzzle that takes a skilled chemist a great deal of time and intuition. The number of possible structures that could produce a given spectrum is huge.

DENDRAL tackled it with a two-part approach:

  1. Plan: Use the expert chemist's rules of thumb to infer constraints, saying, in effect, "this peak suggests a ketone group, that one rules out a certain ring."
  2. Generate and test: Systematically generate all candidate structures consistent with the constraints, then rank them by how well they predicted the observed spectrum.

The key was that the chemists' rules, such as "if the spectrum shows a large peak at mass X, then the molecule probably contains fragment Y," were written down in a form the program could use. DENDRAL's performance in its narrow area matched, and in some cases exceeded, that of human specialists. It was widely used by chemists. A later component, Meta-DENDRAL, even attempted to learn new fragmentation rules from data, one of the first examples of machine learning applied to scientific discovery.

DENDRAL's importance was less its chemistry than its architecture: it separated the knowledge base (the facts and rules about chemistry) from the reasoning mechanism. That separation became the template for the whole expert systems movement.

MYCIN: the system everyone remembers

If DENDRAL was the prototype, MYCIN was the star.

Developed at Stanford in the early 1970s, mostly as the PhD work of Edward Shortliffe (a medical doctor who was also studying computer science), MYCIN was designed to help physicians diagnose bacterial infections of the blood, such as bacteremia and meningitis, and to recommend appropriate antibiotic treatments. Its name came from the suffix of many antibiotics (streptomycin, erythromycin).

This was a real and serious problem. Doctors often had to prescribe antibiotics quickly, before lab results were available, based on partial information. Choosing the wrong drug, or the wrong dose, could be fatal, and over-prescribing broad-spectrum antibiotics contributed to resistance. Specialists in infectious disease were a scarce resource.

How MYCIN worked

MYCIN's knowledge was stored as roughly 500 to 600 if-then rules, which look like this (paraphrased):

IF the stain of the organism is gram-positive, AND the morphology of the organism is coccus, AND the growth conformation of the organism is chains,
THEN there is suggestive evidence (0.7) that the identity of the organism is streptococcus.

Each rule carried a certainty factor, a number expressing how strongly the conclusion followed from the evidence. Medicine is full of uncertainty, and the designers wanted the system to handle it. The certainty factors were an ad hoc method (a rival to probability theory that we'll revisit in Part 10), but they worked well enough in practice.

MYCIN's reasoning was goal-driven. It started with a goal, say, "determine the identity of the infecting organism," and worked backward: which rules could conclude this? What evidence would those rules need? If the evidence wasn't known, the system asked the physician a question. This is called backward chaining. A consultation felt like an interview: the program asked about symptoms, test results, and patient history, then offered a diagnosis and treatment advice.

Explanations: "Why?" and "How?"

One of MYCIN's most admired features was its explanation facility. At any point, a doctor could ask, "Why are you asking me this?" and the system would respond by showing the rule it was trying to apply and the goal it was pursuing. Afterward, the user could ask "How did you reach that conclusion?" and receive the chain of rules and evidence.

This was not just a nicety. It was essential to getting clinicians to trust the system, and it remains a model for what we now call explainable AI. Modern deep learning systems, with their inscrutable internals, often fail precisely where MYCIN succeeded.

The verdict, and the paradox

In a 1979 study published in the Journal of the American Medical Association, MYCIN's recommendations were evaluated by outside infectious-disease experts, who compared them with those of Stanford faculty and others. MYCIN's performance was rated as equal to or better than that of the human specialists. It was a landmark result: a computer program had matched medical experts at a complex diagnostic task.

And yet, MYCIN was never used in clinical practice. There were several reasons. There were unresolved legal and ethical questions: who is responsible if a program gives bad advice? The system had to be run on a large time-shared computer, and a consultation took as much as half an hour of typing in answers, which was impractical for a busy clinic. And, perhaps most fundamentally, the medical profession wasn't ready to hand diagnostic authority to a machine.

The lesson, which AI developers keep rediscovering, is that technical performance is not the same as real-world adoption. Building a system that does the task isn't enough; it has to fit into workflows, legal frameworks, and human trust. (Think about that the next time someone says a new AI model will "replace doctors" overnight.)

The anatomy of an expert system

Whatever the domain, expert systems of the era shared a common structure:

  1. Knowledge base. A collection of facts and rules (usually if-then rules), representing the expert's knowledge.
  2. Inference engine. A general-purpose reasoning mechanism that applies the rules to the problem. The two classic strategies were forward chaining (start with known facts and apply rules to derive new conclusions) and backward chaining (start with a goal and work backward to find supporting evidence).
  3. Working memory. The current facts of the case being solved.
  4. Explanation facility. The ability to show how a conclusion was reached.
  5. User interface. Usually a text-based question-and-answer dialogue.
  6. Knowledge acquisition tools. Ways for knowledge engineers (a new profession) to elicit rules from human experts and enter them into the system.

The elegance of this design was the separation between knowledge and reasoning. You could take MYCIN, strip out the medical rules, and replace them with rules for another domain. This was exactly what EMYCIN ("Essential MYCIN") did: it was a reusable expert system shell, a generic engine into which you could plug your own knowledge base. Shells made it dramatically cheaper to build new systems and helped spawn an industry.

Here is a small, self-contained expert system in Python so you can see the whole pattern at work. It is a toy car-trouble diagnoser with a forward-chaining engine and a "how did you conclude that?" explanation:

# Each rule: (name, set of required facts, fact to conclude) RULES = [ ("R1", {"engine_cranks_slowly", "lights_dim"}, "battery_weak"), ("R2", {"engine_wont_crank", "no_dashboard_lights"}, "battery_dead"), ("R3", {"battery_weak", "battery_old"}, "replace_battery"), ("R4", {"battery_dead"}, "jump_start_then_check_alternator"), ("R5", {"engine_cranks_normally", "engine_wont_start", "no_fuel_smell"}, "fuel_not_reaching_engine"), ("R6", {"fuel_not_reaching_engine"}, "check_fuel_pump"), ] def forward_chain(initial_facts): facts = set(initial_facts) why = {} # conclusion -> (rule, evidence)  changed = True while changed: changed = False for name, conditions, conclusion in RULES: if conditions <= facts and conclusion not in facts: facts.add(conclusion) why[conclusion] = (name, conditions) changed = True return facts, why def explain(fact, why, indent=0): pad = " " * indent if fact not in why: print(f"{pad}- {fact} (observed)") return rule, evidence = why[fact] print(f"{pad}- {fact} [by {rule}]") for e in sorted(evidence): explain(e, why, indent + 1) facts, why = forward_chain({"engine_cranks_slowly", "lights_dim", "battery_old"}) print("Advice:", [f for f in facts if f.startswith("replace")]) explain("replace_battery", why) 

The output is a miniature of MYCIN's "How?" feature: the conclusion replace_battery is justified by two rules and three observed facts. The engine contains no car knowledge at all. Swap the rules for tax law or loan eligibility and the same engine works unchanged. That, in thirty lines, is the architecture that launched a billion-dollar industry.

XCON: the system that paid for itself

The medical systems made headlines, but the system that made money came from an unglamorous corner of the computer business.

A DEC VAX-11/780, the minicomputer whose orders XCON configured
A DEC VAX-11/780, the minicomputer whose orders XCON configured. Image: Dr. Bernd Gross, CC BY-SA 4.0, via Wikimedia Commons.

In the late 1970s, Digital Equipment Corporation (DEC) was one of the biggest computer makers in the world. Its flagship product, the VAX-11/780 minicomputer, was sold as a customizable system: customers could choose from many options for memory, disk drives, cables, and cabinets. The problem was that nobody in DEC's sales or factory staff could reliably check that an order was complete and consistent. Orders arrived with missing components, wrong cables, or incompatible parts, and shipping a system that couldn't be assembled on the customer's site was expensive and embarrassing.

John McDermott at Carnegie Mellon University wrote a program, originally called R1 (and later XCON, for "eXpert CONfigurer"), that took a customer's order and produced a complete, correct configuration: which components to include, how to lay them out in cabinets, and how to cable them. It was written as a rule-based system using the OPS5 language and was put into production use at DEC starting around 1980.

The results were striking. By the mid-1980s XCON was processing tens of thousands of orders, with accuracy that DEC reported as well above that of the human configurers, and the company claimed it was saving tens of millions of dollars a year (figures of $25 to $40 million annually are often cited). It grew from about 750 rules to several thousand, and later to around 10,000.

XCON was the proof-of-profit that business needed. Here was an AI system doing real work, every day, for a Fortune 500 company, and demonstrably saving money. Companies that had never thought about AI started asking: what could this do for us?

The boom

By the early 1980s, expert systems had triggered the first real AI boom in business. The trajectory was remarkable:

A Symbolics 3600, one of the Lisp machines of the 1980s boom
A Symbolics 3600, one of the Lisp machines of the 1980s boom. Image: Retro-Computing Society of Rhode Island, CC BY-SA 4.0, via Wikimedia Commons.

  • Start-ups. Companies such as Teknowledge, IntelliCorp, and Inference Corporation sold expert system shells and consulting. Venture capital poured in.
  • Corporate adoption. Major corporations created in-house AI groups. DuPont, General Motors, Boeing, American Express, Campbell Soup, and many others built expert systems for tasks from diagnosing equipment faults to approving credit. A famous (and probably somewhat polished) tale concerns Campbell's, which captured the knowledge of a retiring veteran who had spent decades troubleshooting its soup-cooking equipment. DuPont was widely reported to be running hundreds of systems and saving millions of dollars a year.
  • Specialized hardware. The Lisp machine, a computer designed from the ground up to run Lisp, the language of AI (see Part 4), spawned an entire industry. Companies such as Symbolics and Lisp Machines Inc. (both spun out of MIT's AI Lab) sold workstations costing tens of thousands of dollars each, and Xerox, Texas Instruments, and others entered the market.
  • Numbers. By the mid-1980s, the AI industry was estimated to be worth around a billion dollars, and by the end of the decade analysts projected it at several billion more. Business magazines ran cover stories declaring that AI had arrived, and by one widely repeated estimate, a majority of the Fortune 500 had some kind of AI effort underway.
  • Professions. "Knowledge engineer" became a job title, and university AI courses were oversubscribed.

Expert systems weren't only in business. PROSPECTOR, built at SRI to help geologists evaluate mineral prospects, was reported to have helped identify a significant molybdenum deposit in Washington State. PUFF interpreted pulmonary function tests. INTERNIST-1, developed at Pittsburgh, was an ambitious attempt to cover the whole of internal medicine and later evolved into the Quick Medical Reference tool. Systems for configuring products, scheduling flights, diagnosing machinery, approving loans, and detecting fraud proliferated.

The Fifth Generation panic

The boom got a geopolitical boost in 1982, when Japan's powerful Ministry of International Trade and Industry (MITI) announced the Fifth Generation Computer Systems project: a ten-year, roughly $400 million national effort to build a new generation of computers based on logic programming (Prolog) and massively parallel inference, designed to run knowledge-based systems and understand natural language.

Western governments panicked. Japan had just outcompeted the US in cars and consumer electronics, and many feared the same would happen in computing. Feigenbaum and the writer Pamela McCorduck published a bestselling book, The Fifth Generation (1983), warning of a Japanese threat. The response was swift: the US launched DARPA's Strategic Computing Initiative (about a billion dollars over a decade) and a private consortium called MCC in Austin, Texas; Britain launched the Alvey Programme, which finally revived UK AI research after Lighthill; and Europe started ESPRIT.

For AI researchers, it was a golden moment. After the cold years of the 1970s, they had money, status, and attention again.

The Cyc project: writing down common sense

One ambitious project from this era deserves its own mention, because it tried to solve the problem that haunts all knowledge-based AI.

Expert systems were smart within their narrow domains but had no common sense. They couldn't tell you that a person can't be in two places at once or that water makes things wet. Every system was an island. In 1984, Douglas Lenat, who had earlier built self-modifying discovery programs, launched Cyc (from "encyclopedia") at MCC. The goal was audacious: to hand-encode the vast web of everyday common-sense knowledge that humans take for granted, millions of facts and rules, so that systems built on top of it would have a foundation of general understanding rather than brittle expertise.

Lenat estimated the job would take about ten person-centuries of effort. A team of knowledge engineers spent decades entering assertions in a formal logical language. The project continued for roughly forty years, accumulating millions of assertions, and was used in some commercial and government applications. But it never delivered the general breakthrough its founders hoped for. Lenat, who died in 2023, remained a committed believer to the end, and he and others argued late in life that large language models, with all their fluency, could be productively combined with the kind of explicit, verifiable reasoning Cyc represents.

Cyc is the great "what if" of symbolic AI. It tested, at heroic scale, the hypothesis that common sense can be written down by hand. The jury is still out, but the mainstream of the field has moved to learning from data instead.

The cracks beneath the boom

While money flowed, serious problems were accumulating. Anyone who had been paying attention to the lessons of earlier chapters might have spotted them.

1. The knowledge acquisition bottleneck

Getting knowledge out of experts' heads and into rules turned out to be slow, expensive, and error-prone. Experts often couldn't explain how they made decisions. Much of their skill was tacit: a feel for the problem, pattern recognition they couldn't articulate. Ask a physician why they suspected a particular condition, and they'd say, "It just looked like it." Feigenbaum himself named this the knowledge acquisition bottleneck.

This is exactly the argument Hubert Dreyfus and his brother Stuart made in their 1986 book Mind Over Machine: that true expertise is intuitive and pattern-based, and that rules capture only the novice and competent stages of skill, not the fluid mastery of an expert. The expert systems movement had, in effect, discovered Dreyfus's critique empirically.

2. Brittleness

Expert systems performed brilliantly inside their domain and failed catastrophically at its edges. Researchers called this brittleness: there was no graceful degradation. A medical system had no idea what to do with a patient who also had an unrelated condition, or who was a child when it expected adults. It wouldn't say "I don't know"; it would give an authoritative-sounding wrong answer. Humans, in contrast, degrade gracefully, falling back on general knowledge and common sense.

3. No learning

An expert system knew only what its builders had put in. It couldn't improve from experience or adapt to new circumstances. If the world changed, someone had to find the outdated rules and rewrite them by hand.

4. The maintenance nightmare

As systems grew, the rule base became a tangled web where changing one rule could have unexpected effects on others. XCON's rule base ballooned to many thousands of rules and required a dedicated team of people to maintain. DEC reportedly employed dozens of staff just to keep it current as products changed. The more successful a system was, the more expensive it became to maintain, a dynamic that anyone who has worked on legacy software will recognize.

5. Uncertainty and weak theory

Certainty factors were convenient but theoretically shaky, and combining uncertain evidence from many rules could produce nonsense. A more principled approach based on probability theory was being developed (we'll see it in Part 10), but it hadn't yet made its way into mainstream practice.

6. Overpromising, again

Vendors and consultants, hungry to sell, promised far more than the technology could deliver. Many corporate projects failed quietly: pilots that never scaled, systems that never went into production, expensive Lisp machines that sat idle. Corporate executives, who had been told that expert systems would transform their business, were left with modest results and large bills.

If this sounds like the pattern from Part 6, it should. The field had once again confused a real, narrow success with a path to general capability.

What expert systems got right

It would be a mistake to treat the expert systems era as merely a cautionary tale. It left a lasting legacy:

  • The business of AI. For the first time, AI products were sold and used at commercial scale, and the field learned to think about deployment, maintenance, and return on investment.
  • Knowledge representation. Researchers developed rich formalisms, such as frames, semantic networks, ontologies, and rule languages, that later influenced databases, the Semantic Web, and knowledge graphs.
  • Explainability. MYCIN's "Why?" and "How?" established the idea that AI should be able to justify itself, an idea that has come full circle with today's push for explainable and trustworthy AI.
  • Business rules engines. Rule-based decision systems are still everywhere, quietly running in banks, insurance companies, tax software, and airline scheduling. Whenever a system makes a decision by checking a stack of explicit business rules, it's a descendant of expert systems, usually no longer called "AI."
  • Human-in-the-loop design. The best systems were assistants to experts, not replacements, a lesson that holds today.

This points to a quirk of the field that is worth naming, the AI effect: as soon as a technique works and becomes commonplace, we stop calling it AI. Rule-based decision software is now just "software." Spell-checkers, route planners, and recommendation engines were once AI research projects. John McCarthy is often quoted as saying, "As soon as it works, no one calls it AI anymore."

Two philosophies: neats and scruffies

Within the symbolic world of the 1970s and 80s, a famous cultural divide became visible. The "neats," like John McCarthy and Allen Newell, preferred clean, logical, provable approaches: formal logic, elegant theory, programs you could prove correct. The "scruffies," like Marvin Minsky and Roger Schank, believed that intelligence was a messy collection of hacks and heuristics, and that you had to build large, complicated, ad hoc systems and see what worked. Expert systems, with their huge piles of hand-tuned rules, were firmly scruffy territory; Cyc was an attempt to be both.

Looking back, both camps were about to be eclipsed. A third group, whom we left in the cold in Part 6, was preparing a comeback.

The seeds of the next shift

During the expert systems boom, away from the spotlight, several developments were quietly setting up the next chapters:

  • In 1982, the physicist John Hopfield published a paper on a new type of neural network that could store and recall memories, reviving scientific interest in the field.
  • In 1986, David Rumelhart, Geoffrey Hinton, and Ronald Williams published a landmark paper popularizing backpropagation, the method for training multi-layer networks that Minsky and Papert had said nobody knew. (This is the subject of Part 9.)
  • In 1988, Judea Pearl published Probabilistic Reasoning in Intelligent Systems, bringing rigorous probability theory into AI through Bayesian networks and offering a principled answer to the uncertainty problem. (Part 10.)

The tide was about to turn from hand-written knowledge to learning from data. But first, the expert systems bubble had to burst.

Where rule engines still live

Expert systems didn't disappear; they got absorbed into the background of everyday software and lost the "AI" label. If you've ever done any of these, you've met a descendant:

  • Tax software. Filing software walks you through an interview, applying thousands of if-then rules from the tax code to decide which forms and deductions apply. It's MYCIN's consultation style, with the physician replaced by you.
  • Loan and insurance decisions. Many underwriting systems still combine statistical scores with explicit business rules, partly because regulators demand that decisions be explainable.
  • Airline and logistics scheduling. Constraint-based planners descend directly from the 1980s knowledge-based systems.
  • Medical decision support. Drug-interaction alerts in hospital records are essentially hand-written rule sets, with all the strengths (transparent) and weaknesses (alert fatigue, hard to maintain) described above.
  • Fraud and compliance checks. Hybrid systems use machine-learned scores to rank cases and rule engines to apply policy.

There is also an interesting echo in the present: many companies building products on large language models find themselves adding explicit rules, guardrails, and validation steps around them, because rules are predictable and auditable in ways that statistical models aren't. The old argument between rules and learning has become a question of how to combine them.

Quick glossary

  • Knowledge engineer: a specialist who interviews experts and encodes their knowledge as rules.
  • Forward chaining: reasoning from known facts toward conclusions.
  • Backward chaining: reasoning from a goal back toward the facts needed to support it.
  • Certainty factor: MYCIN's numeric measure of confidence in a conclusion.
  • Shell: a reusable inference engine with the domain knowledge removed.
  • Knowledge acquisition bottleneck: the difficulty and cost of extracting expert knowledge into a system.

Key takeaways

  • After the first AI winter, researchers pivoted to expert systems: programs that capture the specific knowledge of human experts in a narrow domain.
  • Feigenbaum's Knowledge Principle ("knowledge is power") argued that specific knowledge, not clever general reasoning, is the source of expert performance.
  • DENDRAL (chemistry) and MYCIN (medicine) set the template: a knowledge base of if-then rules plus a general inference engine, with explanation facilities. MYCIN matched human specialists but was never deployed clinically.
  • XCON at DEC saved the company tens of millions of dollars a year, triggering a commercial boom of start-ups, Lisp machines, and corporate AI labs in the 1980s.
  • Japan's Fifth Generation project (1982) spurred a global government funding race.
  • Expert systems suffered from the knowledge acquisition bottleneck, brittleness, inability to learn, and costly maintenance, which pointed toward a coming bust.
  • Their legacy includes business rules engines, knowledge representation, and explainability, though we rarely call them "AI" anymore.

Try it yourself

  1. Extend the car diagnoser. Add five rules for a different problem (a plant that is dying, a slow laptop, a sick pet). Does the same engine work unchanged? Notice how much of the system's quality depends entirely on the quality of your rules.
  2. Add backward chaining. Write a function that starts from a goal (replace_battery) and works backward to ask which facts are needed. This is how MYCIN worked, and it makes interviews like "Is the battery old?" natural.
  3. Find the brittleness. Feed the car system a contradictory set of facts (engine_wont_crank together with engine_cranks_normally). What does it say? What should it say? That gap is brittleness.

Next up

In Part 8, the boom collapses. The market for Lisp machines evaporates almost overnight, expert-system vendors go bankrupt, Japan's Fifth Generation project quietly fizzles, and AI becomes a dirty word again. It's the second AI winter, and understanding why it was even colder than the first helps explain what finally brought the field back.

If your company has an old rule-based system humming away somewhere, tell me in the comments. I'd love to hear the war stories. And follow the series so you get Part 8 as soon as it's out.

See you in Part 8.

☕ If this series helped you, you can support my writing on Ko-fi.

Support me on Ko-fi