An interactive explainer · ~15 min
From data
to agents
Modern AI isn't one idea — it's a stack of ideas, each one built on the layer below it. This page climbs that stack one floor at a time: raw data, then machine learning, then generative AI, then agentic AI. Every layer comes with something you can poke at.
Start at the bottom ↓Data
Everything above this layer is made of data. Before any model learns anything, someone had to collect information, clean it up, and put it somewhere useful. Get this layer wrong and everything built on top of it wobbles.
Data comes in different shapes. Structured data fits neatly into rows and columns — a spreadsheet of sales, a database of customers. Unstructured data doesn't: emails, photos, call recordings, PDFs. In between sits semi-structured data, which has some organization (like labels and nesting) but no fixed table shape — think JSON from an API.
Roughly 80% of the world's data is unstructured. That single fact explains a lot of what happens in the upper layers of this page.
Raw data is rarely usable as-is. It lives in different systems, in different formats, full of duplicates and typos. The classic fix is a pipeline called ETL — Extract data from its sources, Transform it into a clean consistent shape, and Load it into a destination like a data warehouse. (A popular modern variant, ELT, loads first and transforms inside the warehouse.)
- Structured = tables. Unstructured = everything else. Semi-structured = tagged but not tabular.
- Most data in the world is unstructured — and historically it was the hardest to use.
- ETL pipelines turn scattered, messy data into clean, queryable data.
- "Garbage in, garbage out" starts here: data quality caps everything above it.
Why the next layer needs this one: once you have clean data, a new question appears — instead of just storing and querying it, could a machine learn patterns from it? That question is the entire second layer.
AI & Machine Learning
Traditional software follows rules a human wrote: if this, then that. Machine learning flips it — you show the computer examples, and it works out the rules itself.
Artificial intelligence is the broad ambition: software that does things we'd call "smart." Machine learning is the approach that made it practical: algorithms that improve at a task by finding patterns in data — the data you cleaned in Layer 01. A trained pattern-finder is called a model.
There are three classic ways a model learns. Supervised learning uses labeled examples (emails marked spam / not spam). Unsupervised learning finds structure in unlabeled data (grouping customers into segments nobody defined). Reinforcement learning learns by trial, error, and reward (a game-playing bot improving through wins and losses).
That straight line is a model with two knobs (slope and intercept). Real models — like the neural networks behind modern AI — work the same way in spirit, but with millions or billions of knobs, called parameters. Training is the process of nudging every knob, over and over, until the model's predictions stop being wrong. More good data usually means a better model — which is why Layer 01 matters so much.
One caution worth knowing: a model can memorize its training data instead of learning the general pattern — that's called overfitting. It's why models are always tested on data they've never seen.
- ML = learning rules from examples instead of hand-coding them.
- A model is a pattern-finder; its knowledge lives in parameters tuned during training.
- Supervised (labeled), unsupervised (unlabeled), reinforcement (reward) — the three classic modes.
- More and better data → better models. Data quality is still the ceiling.
Why the next layer needs this one: classic ML predicts numbers and labels — a price, spam / not spam. But what if the "label" a model predicts is simply the next word in a sentence? Trained on enough text, that one trick lets a model write. Welcome to Layer 03.
Generative AI
Everything in Layer 02 predicted something small: a number, a category. Generative AI uses the same machinery to predict something huge — the next piece of content — and by predicting again and again, it creates: text, images, code, audio.
A large language model (LLM) is a giant neural network trained on enormous amounts of text — mostly unstructured data, the 80% that Layer 01 said was hard to use. Its core skill is humble: given some text, predict the most likely next token (a word or word-fragment). Do that repeatedly and you get sentences, essays, working code.
The text you give it is the prompt — it's how you steer a model that was never programmed with explicit rules. And because generation is probabilistic, a dial called temperature controls how adventurous its choices are.
This tiny demo has a vocabulary of a few dozen words. Real LLMs choose between ~100,000 tokens at every step, informed by billions of parameters — but the loop you just ran is genuinely the loop. It also explains their famous flaw: the model picks plausible next tokens, not verified ones, so it can state falsehoods fluently. That failure mode is called hallucination.
- GenAI = ML aimed at producing content, not just labels.
- LLMs generate text one token at a time, each choice a probability.
- Prompts steer; temperature trades reliability for creativity.
- Fluent ≠ true: hallucination is plausible prediction without verification.
Why the next layer needs this one: an LLM can now read, reason in text, and write — but only when spoken to, and only with words. What happens if you give it a goal, tools it can call, and permission to keep going until the job is done? That's Layer 04.
Agentic AI
A chatbot answers and stops. An agent is given a goal and works toward it: it plans, uses tools, checks results, recovers from failures, and keeps looping until the goal is done — or until it knows it's blocked.
The heart of agentic AI is a loop: plan → act → observe → adjust. The "brain" is an LLM from Layer 03, but it's wired to tools — search, databases, calendars, email, code — so its words can become actions. Add memory of what it has tried, and the ability to react when a tool call fails, and you get software that handles multi-step work instead of single questions.
The trade is autonomy for oversight: an agent that can act can also act wrongly, which is why real deployments limit which tools an agent gets and keep humans in the loop for consequential steps.
- Agent = LLM + goal + tools + a plan-act-observe loop.
- The loop is what lets it recover from failures instead of stopping.
- Autonomy is a dial, not a switch — guardrails and human checkpoints matter.
- Every layer below is load-bearing: agents reason with GenAI, which learned via ML, which learned from data.
One idea per floor
Data is the raw material. Machine learning finds patterns in it. Generative AI uses those patterns to create new content. Agentic AI puts that creator in a loop with tools and a goal. Remove any floor and the ones above it collapse.