The types of AI: a complete map

People say "AI" to mean a chess engine, a spam filter, a chatbot, a self-driving car and a science-fiction superintelligence. Those systems have almost nothing in common technically, which is why conversations about AI so often go in circles. This lesson gives you a map: a set of independent questions you can ask about any AI system so that you can say precisely what kind of AI it is. Engineers use exactly this vocabulary when they scope a project, choose a model or read a paper.

Intuition: AI is classified on several axes at once

Think about how you would classify vehicles. You can sort them by power source (petrol, diesel, electric, human), by purpose (passenger, freight, emergency), by size, by who controls them (a driver, a remote operator, an autopilot). No single list works, because these are different questions. A delivery van can be electric, freight, medium-sized and human-driven all at once.

AI is the same. "Is it machine learning or rule-based?" is one question. "Does it predict a label or generate new content?" is another. "Does it run on a phone or in a data center?" is a third. A modern chat assistant answers them as: machine learning (specifically deep learning), trained mostly by self-supervised learning and then refined with feedback, narrow (not general) in capability, generative, a transformer, often multimodal, cloud-hosted, and working as a copilot or agent. Keep this "coordinates on many axes" picture in mind for the rest of the lesson.

Axis 1: approach (how the intelligence is built)

Symbolic, rule-based AI and expert systems

Symbolic AI represents knowledge as explicit symbols and rules that a human can read, such as IF temperature > 38 AND cough THEN suspect infection, and uses logical inference to draw conclusions. Expert systems, popular from the 1970s to the late 1980s, packaged a domain expert's rules into a knowledge base plus an inference engine that chained rules together. Strengths: transparent, auditable, needs no training data. Weaknesses: brittle outside the rules, expensive to maintain, and poor at perception (nobody can write rules that recognise a cat in pixels). Symbolic methods are alive today in business-rule engines, tax and compliance software, type checkers and theorem provers.

Search and planning

Many problems can be framed as finding a path through a space of states: a route on a map, a sequence of moves in chess, a schedule for a factory. Search algorithms (breadth-first, A*, minimax with alpha-beta pruning, Monte Carlo tree search) explore that space efficiently; planning systems search over sequences of actions toward a goal. IBM's Deep Blue, which defeated world chess champion Garry Kasparov in 1997, was primarily a massively parallel search engine with a hand-tuned evaluation function, not a learning system. Route planners, logistics optimisers and game AI still rely on search.

Probabilistic and Bayesian AI

Real data is noisy, so a large branch of AI reasons with probabilities instead of hard rules. Bayesian networks encode which variables influence which; hidden Markov models track a hidden state over time (classic speech recognition was built on them); Kalman filters estimate a moving object's position from noisy sensors (used in navigation and robotics). The core idea is Bayes' rule, which updates a belief when evidence arrives:

$P(H \mid E) = \frac{P(E \mid H)\,P(H)}{P(E)}$

where $H$ is a hypothesis (say "this email is spam"), $E$ is the evidence (the words in it), $P(H)$ is the prior belief, $P(E \mid H)$ is how likely the evidence is if the hypothesis is true, and $P(H \mid E)$ is the updated (posterior) belief.

Machine learning, deep learning and generative AI

Machine learning (ML) systems learn their behaviour from data instead of from hand-written rules. Deep learning is the subset of ML that uses neural networks with many layers, which learn their own features directly from raw inputs such as pixels, audio samples or text. Generative AI usually refers to deep models that produce new content (text, images, audio, code). Picture three nested circles: AI contains ML, ML contains deep learning, and most of today's generative AI sits inside deep learning.

One simplification to flag: "generative model" is also an older statistical term for any model of how the data itself is distributed, and some of those (naive Bayes, hidden Markov models) are not deep at all. When people say "generative AI" in 2026 they almost always mean the large deep models.

Hybrid and neuro-symbolic AI

Hybrid systems combine learned components with search or symbolic reasoning. DeepMind's AlphaGo, which beat Go champion Lee Sedol in 2016, paired neural networks (to judge positions and suggest moves) with Monte Carlo tree search. Neuro-symbolic AI aims to join neural networks' perception and pattern-matching with symbolic systems' explicit rules, logic and guarantees. A practical everyday example is an LLM agent that writes code which a deterministic interpreter then runs and checks: learned generation plus exact symbolic execution.

Axis 2: learning paradigm (where the training signal comes from)

Only learning systems have a paradigm, and many real systems use several in sequence.

Self-supervised learning deserves emphasis because it powers large language models: the text supplies its own "label" (the next token), so a model can learn from trillions of words that nobody annotated. Strictly, transfer learning is a strategy rather than a source of signal, but it is so central to modern practice (pretrain once, adapt many times) that it belongs on the list.

The difference between supervised and unsupervised learning fits in a few lines of scikit-learn:

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.cluster import KMeans

X, y = load_iris(return_X_y=True)   # 150 flowers, 4 measurements, 3 species

# Supervised: we give the model the answers (y) during training
clf = LogisticRegression(max_iter=1000).fit(X, y)
print("supervised accuracy:", clf.score(X, y))

# Unsupervised: no labels; the model just groups similar flowers
km = KMeans(n_clusters=3, n_init=10, random_state=0).fit(X)
print("cluster ids of first 5 flowers:", km.labels_[:5])

The classifier learns a mapping to known species names. K-means only returns arbitrary cluster numbers (0, 1, 2); it is your job to work out what each group means. (Scoring on the training data, as above, overstates accuracy; the model-evaluation lesson shows how to hold out a test set.)

Axis 3: capability (how general is it?)

• Artificial narrow intelligence (ANI), or narrow AI, performs specific tasks or a bounded family of tasks. Every AI system deployed today is narrow in this sense, including systems that are superhuman at their task (chess engines) and very broad systems (chat assistants that write, code and analyse) whose competence is still uneven and unreliable outside familiar territory.
• Artificial general intelligence (AGI) is a hypothetical system that matches capable humans across most cognitive tasks, including learning new tasks efficiently. There is no agreed definition. Proposals differ on whether AGI means matching a median adult or an expert, whether physical tasks count, whether it is about performance or about learning ability, and whether economic value is the yardstick. Morris and colleagues at Google DeepMind (2023) proposed "levels of AGI" that grade systems separately on performance (how good) and generality (how broad), precisely because a yes/no label hides too much. When someone claims a system "is AGI" or "is not AGI", ask which definition they are using.
• Artificial superintelligence (ASI) is a hypothetical system that greatly exceeds the best humans across essentially all cognitive domains. It is a subject of forecasting and safety research, not an engineering category you will build with.

As of November 2026, these terms are contested in public debate; the AI 400 lesson on frontier risk and the AGI debate covers the arguments.

Axis 4: predictive vs generative

• Predictive (discriminative) AI maps an input to a decision, score or number: fraud or not, next month's sales, the object class in an image. Formally it models $P(y \mid x)$, the probability of output $y$ given input $x$.
• Generative AI produces new samples that resemble its training data: paragraphs, images, voices, molecules. Formally it models the data distribution $P(x)$ (or $P(x \mid \text{prompt})$) and samples from it.

The boundary blurs in practice: an LLM is generative, yet you can use it as a classifier by asking it to output one label. The useful question is what the output of your system is: a judgment about existing data, or new content.

Axis 5: architecture family (the shape of the model)

On tabular data, gradient-boosted trees often match or beat deep networks and are much cheaper. Transformers dominate language and are strong almost everywhere else. Architectures are tools, not eras: all of these remain in production.

Axis 6: modality (what kind of data it handles)

Modality means the type of data: text, images, audio, video, time series, tabular records, graphs, 3D point clouds, sensor streams. A unimodal model handles one (a speech recogniser maps audio to text); a multimodal model accepts or produces several (a model that reads a chart image and answers a text question). Modality drives your choice of preprocessing, architecture and evaluation metrics far more than the label "AI" does.

Axis 7: deployment (where it runs)

• Cloud: the model runs on a provider's servers and you call it over an API. Access to the largest models; data leaves your device; pay per use.
• On-device / edge: the model runs on a phone, laptop, workstation or local server. Privacy, offline use, low latency, no per-token fee, but limited by memory and bandwidth (the AI 310 course and the site's AI Index quantify this).
• Embedded: a small model inside a dedicated product such as a camera, hearing aid, car control unit or microcontroller, often with strict power and real-time limits.

Many products are hybrids: a small local model handles easy or private requests and routes hard ones to the cloud.

Axis 8: autonomy (how much it acts on its own)

1. Tools answer a single request and stop: a translation, a classification, one generated image.
2. Copilots work alongside a human who approves each step: code completion, drafting an email you then edit.
3. Agents pursue a goal over many steps, choosing actions (search, run code, call APIs, click in a browser) and observing results, with a human supervising at checkpoints or only at the end.

Autonomy is a dial, not a switch, and it is a design decision: the same underlying model can be deployed as a tool or as an agent. More autonomy means more value per instruction, and also more ways to fail and more need for guardrails and evaluation.

Worked example: classifying three systems

Notice the robot vacuum: it is not "an AI" of one kind but a stack of different AI types. That is typical of real products, and the main reason this multi-axis map is more useful than any single label. (The exact components vary by manufacturer; the table describes a typical design.)

Where each type is taught in this program

Common pitfalls

• Treating "AI" and "machine learning" as synonyms. Plenty of production AI is search, optimisation or rules. If a rules engine solves your problem transparently, it may be the better choice.
• Treating generative AI as the whole field. Most AI value in business still comes from predictive models on tabular data: forecasting, scoring, ranking, detecting.
• Collapsing axes. "Is it deep learning or is it an agent?" mixes the approach axis with the autonomy axis; a system can be both.
• Using "AGI" without a definition. Claims about AGI arriving, or not, are meaningless until you say which definition and which test.
• Assuming newer architecture means better. Gradient-boosted trees still win many tabular problems; a small CNN may beat a large transformer on a tiny embedded device.
• Forgetting deployment early. A model that needs a data-center GPU cannot ship inside a battery-powered sensor; deployment constraints should shape the design from day one.

In practice

When you join a project or read a vendor pitch, write down the system's coordinates on all eight axes in a short table, like the worked example. It forces precise questions: Where do labels come from? What exactly is the output? Where will it run and what does that cost? How much autonomy, and who reviews its actions? Professionals choose the simplest type that meets the requirement (rules, then classic ML, then deep learning, then large generative models), because each step up usually adds cost, latency and new failure modes along with capability. Expect real products to be stacks of several types, and evaluate each component with metrics suited to its own type.