"AI" is one of the most overloaded terms in technology. In 2026 it is used to mean at least five different things, and which thing it means in any given sentence is rarely stated. This piece walks through the generations the word has covered, so an operator can read product pages and press releases without being misled.
The short version: the agent is the latest turn in a story that started in the 1950s. Each turn produced systems that looked smart for different reasons. The reasons matter because they determine what the system can and cannot do.
Generation 1 — rules and expert systems (1950s–1980s)
The earliest AI was built by hand. A team of experts wrote rules: "if the patient has fever and a rash, then suggest measles." The system applied the rules to inputs and produced outputs. This was called expert systems in the 1980s, and it was a real industry — companies were sold and bought on it.
The strengths were predictable behavior and explicit knowledge — you could read the rule base and see what the system knew. The weaknesses were brittleness and cost. Adding a new rule could break existing ones. The knowledge acquisition bottleneck — getting experts to actually write down everything they knew — was severe.
If you have ever used a corporate "decision tree" troubleshooting tool, you have used a descendant of this generation.
Generation 2 — classical machine learning (1990s–2010s)
The next generation inverted the problem. Instead of writing rules by hand, engineers wrote algorithms that learned rules from data. Given a thousand labeled examples of (email text, spam or not), an algorithm could produce a classifier that, on new emails, predicted spam or not.
This is machine learning, and it is the workhorse of the 2010s internet: spam filters, recommendation systems, fraud detection, ad targeting, voice transcription, machine translation. Most of the "AI" you used between 2010 and 2020 was this generation.
The strengths were that ML handled messy data and improved with more examples. The weaknesses were that the algorithms needed labeled data, worked best in narrow domains, and produced models whose decisions were often hard to explain. The vocabulary around this generation — training set, feature, classifier, regression — is still the lingua franca of applied AI teams.
Generation 3 — deep learning (2010s)
Around 2012, a specific family of ML algorithms — neural networks with many layers — started winning every competition they entered. Image classification, speech recognition, machine translation, game-playing: each was retaken by a deeper, larger network trained on more data.
Deep learning did not replace classical ML. It took over the tasks where the input was raw and high-dimensional: pixels, audio waveforms, characters in a sentence. Classical ML is still used where the input is structured tables of numbers.
If you have used face recognition on a phone, voice dictation, or a real-time translation app, you have used deep learning.
Generation 4 — large language models (late 2010s–now)
The next step was to apply deep learning to a much harder input: arbitrary human text. The breakthrough was realizing that a single neural network, trained on enough text with a simple objective (predict the next token), could absorb a remarkable amount of language, reasoning, and world knowledge.
That is the large language model (LLM) covered in What Is an LLM?. The chat products that took the consumer market by storm in the early 2020s — ChatGPT, Claude, Gemini, and the rest — are LLMs wrapped in a chat interface.
LLMs are still generation 4. They have a specific shape: next-token prediction, finite context, structured tool use. They are generative in the sense that they produce new text on demand. They are not databases, they are not search engines, they are not reasoning engines in the formal sense. They are very capable predictors that, when wrapped well, do useful work.
Generation 5 — agents (mid 2020s–now)
The most recent turn is agents: an LLM inside a loop, with memory, with tools, and with a stop condition. The agent is covered in What Is an AI Agent? and the agent loop glossary entry.
The shift from generation 4 to generation 5 is not a new model. It is a new architecture. The LLM is one component. The loop, the tools, the memory, the planning, the verification — those are the new parts. Most of what people call "AI" in 2026 is actually this generation: a system that takes a goal and works on it over time through tool calls.
This is also the generation this manual is mostly about. If you are here, you are probably building or operating an agent.
What the marketing term conceals
When a product page says "AI-powered," it can mean any of the five generations above. A few examples to calibrate:
- "AI-powered spam filter" — almost certainly classical ML.
- "AI-powered camera autofocus" — almost certainly classical ML or shallow deep learning.
- "AI assistant that summarizes your meetings" — almost certainly an LLM.
- "AI agent that books your travel" — an LLM inside an agent loop, with calendar and booking tools.
- "AI co-pilot that debugs your code" — usually an LLM, sometimes with retrieval over your codebase, sometimes with tool calls to a sandbox.
The product name does not tell you which generation is at work. The architecture does. When you build or buy, the question to ask is not "is it AI?" but "which generation, doing what, on what data, with what guardrails?"
Common confusions worth clearing up
A short catalog of claims that come up in conversation and that do not survive a careful read.
"AI can think." Models produce text. Whether that constitutes thinking depends on a definition nobody has settled. What is settled is that the model has no persistent inner state, no awareness of itself, and no continuity across sessions. What it has is a very capable next-token predictor wrapped in a loop.
"AI is always right." It is not. Each generation has its own failure modes. Generation 2 fails on out-of-distribution inputs. Generation 4 hallucinates. Generation 5 plans badly. The question is not whether the system will be wrong; it is how often, on what kinds of inputs, and whether your design catches the failures.
"AI will replace every job." Tools replace tasks. Some tasks are big chunks of jobs, and over time those chunks shift. But the claim that "AI" as a single thing will replace a category of work does not hold up — different jobs use different generations, and the generations do different things.
"AI is a black box." It is partially inspectable. The weights are inspectable (for open models). The prompts are inspectable. The tool calls are inspectable. The traces are inspectable. The internals of the model's reasoning on a specific input are not inspectable. The opacity is real but narrower than the slogan suggests.
"AI is one thing." It is at least five generations and several architectures per generation. If your plan treats it as one thing, your plan will be wrong somewhere.
What is still missing from the picture
A short list, written for the agent builder who is sizing up what to expect.
Real grounding. LLMs and agents are still mostly working in language and through language-mediated tools. A robot that walks through a warehouse and picks up boxes is not an LLM agent in the same sense; it is a robotics stack with maybe an LLM as a planner. The gap between "text on a screen" and "body in the world" is still real and large.
World models. LLMs have a fuzzy sketch of the world, compressed into their weights. They do not have a world model in the sense of an internal simulator that can be stepped forward in time. They predict what comes next in text. For tasks that require simulating the world — physics, planning over long horizons, multi-agent interaction — the LLM is being asked to do something it was not designed for, and it usually needs help.
Stable memory. Agents use external memory, and that memory is something the operator has to design. There is no built-in reliable memory that survives across sessions, across model upgrades, across context overflow. See Why Memory Is the Hardest Part.
Guaranteed correctness. Generation 4 systems hallucinate. Generation 5 systems plan, but the plan is text, and text can be wrong. There is no model that, when asked to do a non-trivial multi-step task, will reliably get every step right. The answer is verification, governance, and human review at the right points — covered in Evaluation, Safety, and Governance.
Long-horizon autonomy. Today's agents can run for minutes or hours. Running for days or weeks, on goals that evolve, with the world changing underneath, is still hard. Most production agents are supervised: a human or a cron checks in.
How an agent builder should think about the label
A few habits that pay off.
1. Name the generation in your own docs. "We use an LLM (generation 4) inside an agent loop (generation 5) to triage incoming email." That sentence tells a future reader exactly what is going on. "We use AI" tells them nothing. 2. Match the generation to the task. If you are classifying support tickets, generation 2 or a small fine-tuned classifier will be cheaper and more accurate than an LLM. If you are drafting responses to open-ended customer emails, an LLM is the right tool. If you are booking flights, you need an agent. 3. Budget for the failures of the generation you picked. ML models need labeled data and drift monitoring. LLMs need verification, retrieval, and guardrails. Agents need governance, audit, and stop conditions. Each generation has its own failure modes; pick the one whose failures you know how to handle. 4. Treat "AI" as a stand-in. When someone says "AI," ask which generation, which model, which loop, which guardrails. Most of the value of asking is that you find out whether they know.
The rest of this manual assumes you are working in generation 4 and 5 — building on top of LLMs, and putting them inside agent loops. The next read is What Is an AI Agent?, which goes from "what is AI" to "what is an agent" in one step.