The Six Layers Of AI
Classical AI, machine learning, neural networks, deep learning, generative AI, agentic AI. The six names are the right six, and the popular graphic gets one thing wrong that changes what you conclude from it. What each layer is, what it cannot do, and which to reach for.
A graphic circulates every few months listing the six layers of AI: classical AI, machine learning, neural networks, deep learning, generative AI, agentic AI. It is a good list. Those are the right six names, they are the ones you will hear in a vendor meeting, and knowing them in order is most of what it takes to follow a technical conversation without nodding along.
It gets one word wrong, and the word is "layers".
Drawn as a stack, the six look like six separable technologies sitting on one another, the way an application sits on a database which sits on an operating system. They are not that. Neural networks are machine learning. Deep learning is neural networks, with more of them. Generative models are an application of deep learning. And classical AI is not the ground floor that the rest was built on — it is a sibling of the entire learned branch, and it never stopped being the right answer for a large class of problems.
That is not pedantry. Three expensive decisions follow from the stack picture, and this article is mostly about those.
The six are nested, not stacked
The six, briefly and honestly
1. Classical AI — rules a person wrote
If this, then that. A tax calculator, a chess engine's opening book, the routing logic that decides which queue a support request lands in, the rules your bank uses to flag a transaction. Somebody worked out the logic and wrote it down.
What it is good at: anything where the rule is knowable and the answer must be explainable, auditable and identical every time. Nothing else matches it on those three.
What it cannot do: handle a situation nobody anticipated, or problems where the rule exists but nobody can articulate it — recognising a face, judging a tone.
The thing people get wrong: treating it as obsolete. A large share of what gets sold as AI is, and should be, rules. If you can write the rule down, write the rule down. It is cheaper, faster, testable, and it never hallucinates.
2. Machine learning — rules inferred from data
Rather than writing the rule, you supply many examples of input and correct output, and a training process finds a rule that fits them. Spam or not. Will this customer churn. What is this house worth.
What it is good at: problems where the pattern is real but nobody can state it, and where you have enough labelled examples to show it.
What it cannot do: explain itself in the way a rule can, or work outside the distribution it was trained on. A model trained on five years of calm markets has never seen a crash and does not know that.
The thing people get wrong: underestimating the data. Most machine learning projects fail on the examples, not the algorithm — which is why the discipline of producing them has an article of its own.
3. Neural networks — a particular way of learning
A specific family of machine-learning model, loosely inspired by neurons: layers of simple units, each passing a weighted signal to the next, with the weights adjusted during training until the output matches the examples.
What it is good at: patterns too tangled for simpler models — images, audio, language.
What it cannot do: anything a simpler model does better. A neural network on tabular business data is frequently beaten by methods that are decades older, faster to train and easier to explain.
The thing people get wrong: thinking this is a separate technology from machine learning. It is a subset. Every neural network is machine learning; most machine learning is not neural networks.
4. Deep learning — the same thing, much deeper
Neural networks with many layers. "Deep" is literally the number of layers. What made this work was not a conceptual breakthrough so much as hardware that could train very large networks and datasets large enough to fill them.
This is where the architectures you hear named live: convolutional networks for images, transformers for sequences. A transformer is a deep neural network with a particular way of letting each part of the input attend to every other part, which turned out to work extraordinarily well on language.
What it is good at: learning representations — turning a sentence or an image into a list of numbers that captures what it means, which is what makes search, recommendation and retrieval work.
What it cannot do: learn from small data. These need volume.
The thing people get wrong: assuming more depth is always better. Depth buys capacity, and capacity you do not need buys cost and latency, which is an architectural constraint, not a line item.
5. Generative models — predicting the next piece
Train a deep network on enough text and the task "predict what comes next" produces something that can write. The same idea covers images, audio, video and code. Large language models are the instance everyone means.
What it is good at: producing plausible, fluent, well-formed output in response to almost anything, with no task-specific training.
What it cannot do: know whether what it produced is true. Plausibility is the objective it was trained on. Correctness is not, and it is worth sitting with that sentence, because almost every failure mode follows from it.
The thing people get wrong: the demo. A generative system is unusually easy to make impressive in ten minutes and unusually hard to make reliable, which is a gap with its own name.
6. Agentic systems — a model that acts
Give a generative model tools it can call, let it decide which to call and in what order, and loop until it judges the task done. It books the meeting rather than drafting the email about the meeting.
This is the one that genuinely is different in kind, and it is why the diagram above puts it outside the nesting. The other five describe what a model is. This describes what you build around one. The same model is generative on Monday and agentic on Tuesday because you gave it tools and a loop.
What it is good at: multi-step work with a checkable end state.
What it cannot do: reliably know when it has failed. A system that can act can act wrongly, repeatedly, quickly.
The thing people get wrong: granting it more authority than the verification around it can support. The library covers this at length, starting with what makes a system agentic and designing agents with bounded authority.
The three conclusions the stack picture causes
That the earlier layers are obsolete. They are not superseded, they are nested and still separately useful. A team that reaches for a language model to do what a lookup table does has bought non-determinism, latency and a per-call cost in exchange for nothing.
That progress means climbing. It suggests the right move is always to the layer above. The right move is to the simplest layer that solves the problem, and that is often several floors down. "Could this be a rule?" is the cheapest question in the discipline and the one least often asked.
That the layers are independently selectable. You do not choose between deep learning and generative AI; the second is made of the first. The real choices are narrower and more practical: rules or a learned model; a small specialised model or a large general one; a single call or an agent loop.
What to reach for
| If the problem is | Reach for | Because |
|---|---|---|
| A rule you can state | Rules | Deterministic, auditable, free to run |
| A pattern in structured data you cannot state | Classical machine learning | Small data, fast, explainable enough |
| Images, audio, or meaning in text | Deep learning | Nothing simpler handles this |
| Open-ended language in or out | A generative model | No task-specific training needed |
| Multi-step work with a checkable end | An agent | Only once you can verify the end |
The row that catches people is the last one. An agent is worth building when you can check whether it succeeded. If you cannot, you have not built an agent, you have built something that takes actions and reports success, which is worse than nothing because it is trusted.
Where the rest of this library picks up
This article is the map. The territory is in the other pieces:
- Data and measurement: the three jobs of labelling, then evaluation harnesses for LLM systems and testing non-deterministic systems.
- Building with generative models: RAG architecture that survives production, the demo to production gap, inference cost as an architectural constraint.
- Agents: what makes a system agentic, agent architecture patterns, tool design and the Model Context Protocol, designing agents with bounded authority, evaluating agents, running agents in production.
- What it does to delivery: the transaction cost collapse, verification is the new bottleneck, and what AI does not change.
What to do on Monday
Take one thing in your organisation currently described as AI, and work out which of the six it actually is. Not which one the vendor's slide says — which one the system is.
Then ask the question the stack picture discourages: could the layer below have done this? If the answer is yes, you have found either a saving or a decision somebody should be able to justify. Both are worth knowing.