Understand the nested map of AI, machine learning, deep learning, and where agents fit.
0/0
Use Photo Sorter, a simple app handling 20 phone photos, to decide what counts as artificial intelligence and why people reach for it. You separate goal-directed behavior from ordinary software rules.
Defines artificial intelligence as goal-directed software that uses judgment rather than fixed rules, using a photo-sorting app as the anchor example.
In plain words — Think of AI as the difference between a vending machine (always does the same thing when you press a button) and a helpful friend who looks at your situation and decides what to do.
Why this matters: Before you can understand machine learning or deep learning, you need a clear mental model of what AI is and why you would reach for it — this module builds that foundation.
After this you'll be able to
Define artificial intelligence in plain words.
Identify why a task might call for artificial intelligence.
Sort simple systems into AI and non-AI examples.
Decision this forces: Decide whether Photo Sorter's helpful behavior belongs inside the artificial intelligence box.
What Makes Software 'Intelligent'?
In plain wordsOrdinary software is like a vending machine: you press B3 and it always drops the same chips — no judgment, no adaptation. AI is like a helpful friend who looks at your 20 photos and figures out which ones are blurry, even though nobody told them the exact pixel rules.
You have 20 phone photos and you want to sort the good ones from the blurry ones. A normal app follows a fixed list of rules someone typed in — if brightness < 40, mark as dark. But what if the rules are too hard to write? That is exactly when people reach for .
AI is software that pursues a goal by making decisions, rather than just following a fixed script. It looks at a situation, judges it, and picks an action — even in cases it has never seen before.
The key test is simple: does the software decide, or does it only execute? A thermostat executes (if temp < 68°F, turn on heat). A system that looks at your photos and judges 'this one is worth keeping' is deciding — that is the AI box.
Before reading on, predict: is a spell-checker that flags words not found in a dictionary AI or not? Hold your answer — the next card will test it.
Goal-Directed Behavior vs. Fixed Rules
AI differs from ordinary software in two ways. It has a goal to reach. It uses judgment to reach it — not a lookup table.
A like a spell-checker matches words against a list. It has no goal. It just checks membership. That is not AI — it is a lookup.
Photo Sorter's goal is 'find the best photos.' To reach it, the system must judge sharpness, lighting, and composition. These qualities resist reduction to a single number. That judgment puts it inside the AI box.
Has a goal it is optimizing toward → AI territory
Applies judgment to new, unseen cases → AI territory
Follows a fixed list of hand-written rules → not AI (just software logic)
Photo Sorter receives 20 photos and labels each 'keep' or 'skip.' Watch how it handles three photos. Notice where judgment replaces rules.
Photo 1 — clearly blurry
The system judges: edges are soft, faces unrecognizable. Goal: find best photos. Decision: skip. The evidence is strong.
Photo 2 — slightly dark but sharp
A fixed rule ('if dark, skip') would discard this. But Photo Sorter's goal is 'best photos,' not 'brightest photos.' It judges sharpness matters more. Decision: keep. A rule-based system would fail here.
Photo 3 — never seen this lighting before
No rule covers this case. Photo Sorter judges based on its goal. A rule-based system would crash or default wrong. This moment separates AI from ordinary software.
Before moving on, sort these four systems yourself. For each one, ask: does it pursue a goal using judgment, or does it execute a fixed rule? Write your answers, then read the reveals below.
Stop — attempt this before reading on. Hints: (1) Can it handle a case its designers never wrote a rule for? (2) Is there a goal it is trying to optimize?
A music app that recommends songs based on what you skipped last week.
A calculator that adds two numbers.
An email app that auto-sorts messages into folders you named.
A navigation app that re-routes you around a new traffic jam.
Reveals
AI — it has a goal (songs you will like) and judges new patterns it has never seen.
Not AI — fixed formula, no goal, no judgment.
Not AI — you wrote the rules (the folder names); the app just executes them.
AI — it pursues a goal (fastest route) and adapts to a situation (the jam) it could not have had a pre-written rule for.
Photo Sorter lands in the same column as the music recommender and the navigation app: it pursues a goal and makes judgment calls. That is why it belongs inside the box.
The next module asks a sharper question: inside that AI box, how does Photo Sorter actually get its judgment? The answer is that it could learn from 200 labeled photos instead of following rules someone typed — and that is where machine learning begins.
AI or Not? Click to Find Out
Click each query to see which examples land near it. Systems that decide and pursue a goal cluster near 'AI'; systems that only execute fixed rules cluster near 'Not AI'.
When 'AI' Labels Go Wrong
Calling something AI when it is not — or missing real AI when it is present — causes real problems. Here are three ways this breaks.
Mistaking a lookup for judgment. A team labels their rule-based spam filter 'AI-powered.' When new spam patterns appear, the filter misses every message. The fix: check whether the system handles cases its designers never wrote rules for.
Assuming AI means correct. Photo Sorter keeps a blurry photo because its goal was 'maximize brightness,' not 'maximize sharpness.' Wrong goal, wrong output, no error message.
Invisible goal drift. Photo Sorter is updated to favor photos with faces. Now it skips beautiful landscapes every time. Behavior changes with no warning — the goal changed, not the code. Watch for silent shifts after updates.
Use when
The task involves judgment calls that are too varied or subtle to capture in a hand-written list of rules — like deciding which of 20 photos is worth keeping.
Avoid when
The task has a small, fixed set of cases that a simple lookup or formula handles perfectly — like converting Fahrenheit to Celsius or sorting a list alphabetically.
Rule of thumb
If you can write every rule on one page and they cover every future case, use ordinary software. If the cases are open-ended and judgment is required, you are in AI territory.
Trace how Photo Sorter could learn from 200 labeled photos instead of following hand-written rules. You compare a rule-based blur detector with a learned classifier.
Machine learning is the branch of AI where a program learns patterns from labeled examples instead of following hand-written rules.
In plain words — It's like teaching a new hire by showing them hundreds of past cases instead of handing them a rulebook — they figure out the pattern themselves.
Why this matters: Understanding ML vs. rules tells you when to collect training data and when to just write an IF/THEN — a decision Photo Sorter's labeler forces immediately.
After this you'll be able to
Define machine learning as a subset of artificial intelligence.
Distinguish learned behavior from hand-coded rules.
Explain what training data does in a simple model.
Decision this forces: Decide whether Photo Sorter's labeler is using rules, machine learning, or both.
Recap: Rules Can Only Go So Far
Before reading on, predict from memory: In module 1, Photo Sorter used a rule-based system to decide if a photo was blurry. What does a rule-based system actually do — and what happens when you hit a case the rules didn't cover?
Answer: a follows hand-written IF/THEN instructions. Example: "IF blur score > 0.8, mark blurry." It works for cases the programmer thought of. It fails silently on everything else.
That gap is where this module starts. You have 200 labeled photos and no time to write rules for every edge case. There must be a better way.
Machine Learning: Patterns, Not Rules
In plain wordsTeaching a child to spot dogs is like training a model: you don't recite rules — you show hundreds of pictures until the pattern clicks on its own.
(ML) is a branch of where a program learns patterns from examples instead of following hand-written rules.
You feed it — labeled examples the program can study — and it builds a (a compact summary of what it learned).
Once trained, the model makes a on new, unseen data — without you writing a single new rule.
ML sits inside AI — it is one way to build intelligent behavior, not a replacement for the whole field.
Imagine you hand Photo Sorter's labeler 200 photos. Each is tagged by a human: "beach," "cat," "dog," or "blurry."
The ML algorithm studies those 200 examples and notices patterns. Beach photos tend to be bright blue and wide. Blurry ones have low sharpness scores. Cats have pointy ears.
It compresses those patterns into a — a small set of numbers that capture what it learned.
Now give it photo #201, which it has never seen. The model outputs a : "beach, 92% confident." No new rule was written. The 200 labeled examples did all the teaching.
Training data: the 200 labeled photos (the teacher)
Model: the learned pattern summary (the student's memory)
Prediction: the label on photo #201 (the test answer)
illustrative pseudocode — not meant to run
# Photo Sorter — learned labeler (illustrative pseudocode)# Step 1: training data — 200 labeled photos
features = extract_features(photos) # e.g. brightness, sharpness, color
labels = ["beach", "cat", "blurry", ...] # human tags, one per photo# Step 2: create a simple classifier model
model = SimpleClassifier()
# Step 3: ??? — teach the model using features AND labels# TODO: fill in the training call# Step 4: predict the label for a new, unseen photo
new_photo = extract_features([photo_201])
print(model.predict(new_photo)) # → ["beach"]
Syntax breakdown
extract_features(photos)
Converts each raw photo into a list of numbers (brightness, sharpness, color) the model can work with.
SimpleClassifier()
Creates a blank model — it has no knowledge yet; training fills it in.
model.predict(new_photo)
Runs the learned patterns against a new photo and returns the most likely label.
# TODO
This is the crux: the model must be shown both features and labels together so it can learn the mapping.
Below is Photo Sorter's mini ML pipeline — but the key training line is missing. Stop and predict what goes in the blank before revealing the answer.
Stop — attempt this before revealing. Hints: (1) the model needs to see both the features AND the correct labels; (2) the method that does this in most ML libraries is called fit.
Predict: What single line replaces the TODO to train the model? What does that line need as inputs — and why both?
model.fit(features, labels)
Changed line: model.fit(features, labels) — this is the training call.
Why both inputs: 'features' gives the model the raw signal (what the photo looks like); 'labels' gives it the correct answer to aim for. Without labels, the model has nothing to learn from. Without features, it has nothing to pattern-match on. The fit() call adjusts the model's internal numbers until its predictions match the labels as closely as possible.
Rules vs. ML: Where Each Lives
Click a query to see which approaches sit closest to it. Axes: left = rule-driven, right = data-driven; bottom = rigid, top = flexible.
Rules vs. ML for Photo Sorter's Labeler
Option
Handles new edge cases
Needs labeled examples
When to choose
Cost
Complexity
Rule-Based Blur Detector
Fails on cases the programmer didn't anticipate
No — rules are written by hand
When the logic is simple, stable, and fully known upfront — e.g. "flag anything with blur score > 0.8."
Zero data collection; instant to write
Low — a few IF/THEN lines
Learned ML Classifier
Generalizes to unseen photos if training data was varied
Yes — quality labels are essential
When the pattern is too complex to hand-code — e.g. distinguishing cats, dogs, beaches, and blurry shots from raw pixels.
Requires labeled training data (e.g. 200 tagged photos)
Medium — requires a training loop and evaluation
Hybrid (Rules + ML)
ML part generalizes; rule part still breaks on unknowns
Only for the ML component
When some decisions are simple enough for rules (date sorting) and others need learning (label prediction).
Data for the ML part; engineering time for both
Medium-high — two systems to maintain
How the Learned Labeler Breaks
ML fails in three common ways. Two of them leave no error message.
Biased training data → biased predictions. If all 200 training photos were taken indoors, the model has never seen a beach in sunlight. It will confidently mislabel outdoor shots. You see wrong labels, not a crash.
Too few examples → the model memorizes, not learns. With only 10 cat photos, the model learns those 10 cats, not "cat." New cats get labeled "dog" or "unknown" — again, silently wrong.
Label noise → garbage in, garbage out. If a human tagger marked blurry photos as "beach" by mistake, the model learns that mistake. The symptom: confident predictions that make no sense on obvious cases.
Verify AI-generated labelers: check that training labels are consistent, that every category has at least ~50 varied examples, and that you test on unseen photos.
What's Next: Layers Inside the Learner
You now know that ML learns from labeled examples instead of following hand-written rules.
But Photo Sorter's labeler doesn't just count brightness. It looks at raw pixels and decides "cat" or "beach." That takes a much more powerful model.
The next module opens up that model: a — the engine behind — which stacks layers of pattern-detectors to turn raw pixels into a confident label.
Deep learning is ML taken further: same idea (learn from data), but with far more layers and far more power. That's exactly where Photo Sorter's real image labeler lives.
Follow Photo Sorter's image labeler as a neural network turns photo pixels into a cat, dog, beach, or blurry prediction. You place deep learning inside machine learning, not beside it.
Deep learning is a type of machine learning that uses a neural network — a stack of layers — to turn raw data like pixels into predictions like 'cat' or 'beach'.
In plain words — It's like a relay race where each runner transforms the baton a little more, so by the finish line raw pixels have become a confident label.
Why this matters: Understanding deep learning as a subset of ML (not a synonym for AI) lets you correctly label what Photo Sorter's image labeler is doing and choose the right tool for the job.
After this you'll be able to
Define deep learning as a subset of machine learning.
Describe a neural network as layers that transform numbers.
Name examples that use deep learning without treating all AI as deep learning.
Decision this forces: Decide when Photo Sorter's learned labeler should be called deep learning instead of general machine learning.
Recall: How ML Learns from Photos
Before reading on, predict: In module 2, Photo Sorter switched from hand-written rules to machine learning. What did it learn FROM, and what did it produce? Answer from memory, then check below.
Answer: Photo Sorter learned from 200 labeled photos: learned rules that predict labels on new photos.
That's the foundation. Now: what happens when photos are too complex for simple rules? Photo Sorter must distinguish cats, dogs, and beaches.
Deep Learning Lives Inside ML
In plain wordsA neural network is like a relay race: each runner (layer) takes a baton (numbers), does their job, and hands a transformed baton to the next runner — by the finish line, raw pixels have become a label like 'cat'.
— it sits inside ML, not beside it.
: a stack of layers that transforms numbers into new numbers.
"Deep" means many layers. More layers let the network learn complex patterns, like the difference between a cat's ear and a dog's ear.
Not all ML is deep learning. A simple blur detector trained on 200 photos is ML but not deep learning.
Layers Turn Pixels into Labels
Every photo is a grid of numbers — each pixel is a brightness or color value.
Output layer — features → label: cat / dog / beach / blurry
Photo Sorter now needs to label 1,000 new photos — cats, dogs, beach shots, and blurry ones — without a human checking each one.
A simple ML classifier (like the blur detector from module 2) would struggle here. It learned one pattern — sharpness — but it has no way to tell a fluffy cat from a fluffy dog.
learns layers of features automatically — no human writes rules like "if pointy ears AND whiskers THEN cat".
: "cat — 91% confident". That confidence score comes from the final layer's numbers.
Key point: This labeler IS machine learning (it learns from data). It is ALSO deep learning (it uses a layered neural network). Deep learning is a subset — you can always call it ML, but not all ML is deep learning.
Stop — attempt this before reading the answer. Photo Sorter's neural network processes a new photo. Layer 1 detects sharp edges. Layer 2 finds two pointed shapes at the top and a small oval below them. Layer 3 recognises "pointed ears" and "nose". What does the output layer predict, and why? Hint 1: think about which label matches pointed ears + nose. Hint 2: the output layer picks the label whose features best match what the earlier layers found.
Answer: "cat" — high confidence. Layer 3 passed up the features "pointed ears" and "small oval nose". The output layer has learned that this combination maps strongly to cat, not dog (rounder ears), beach (no ears), or blurry (no sharp edges at all).
.
In the next module you'll apply three quick tests — does it act intelligently, learn from data, use layered networks? — to classify every one of Photo Sorter's features and finally draw the full AI → ML → deep learning boundary.
How Depth Changes What a Network Sees
Drag to see what Photo Sorter's network can detect at each depth. More layers = more abstract understanding.
Three Ways the Labeler Fails
Deep learning is powerful, but Photo Sorter's labeler fails in predictable ways.
Too little training data — If the labeler trains on 50 cat photos instead of 5,000, it memorizes those 50. New cats get labeled "dog" or "beach". You see high accuracy on training photos but random results on new ones.
Wrong labels in training data — If 10% of "dog" photos are actually cats, the network learns that confusion. It labels some cats "dog" every time — no error message, just quietly wrong.
Photos outside training scope — The labeler trained on daytime photos. At night, pixel values shift. It may label every night photo "blurry" because that's the closest pattern it knows. The model returns a confident score anyway.
Verify AI-generated labelers: Check that training data covers all four label types equally. Test on unseen photos. Look for high confidence paired with obviously wrong labels — that signals a mismatch between training data and reality.
Use when
Call it deep learning when Photo Sorter's labeler uses a neural network with multiple layers to learn features automatically from raw data — for example, going from pixels to 'cat' without hand-written rules.
Avoid when
Don't call it deep learning when the model uses a simple learned formula or a small set of rules — like the blur detector that checks one sharpness score. That's machine learning, but not deep learning.
Rule of thumb
If the model has layers that each transform numbers into new numbers, it's deep learning. If it learns one pattern from data with no layered structure, it's ML but not deep learning.
Classify Photo Sorter's features by asking three tests: does it act intelligently, does it learn from data, and does it use layered networks? You practice moving examples into the right nested box.
A three-test framework that places AI, ML, and deep learning in their correct nested relationship.
In plain words — Like Russian nesting dolls — AI is the outer doll, ML fits inside it, and deep learning is the smallest doll tucked inside ML.
Why this matters: Lets you label any product feature accurately so you scope the right data, cost, and timeline from the start.
After this you'll be able to
Compare artificial intelligence, machine learning, and deep learning using clear criteria.
Classify examples at each hierarchy level.
Correct the common mistake that all artificial intelligence is deep learning.
Recall: Where Deep Learning Lives
In plain wordsThe three terms are like Russian nesting dolls: AI is the outer doll, ML fits inside it, and deep learning is the smallest doll tucked inside ML.
Before reading on, predict from memory: In module 3, where did deep learning sit relative to machine learning — beside it, inside it, or above it? Picture the boxes from that module and answer before scrolling.
Deep learning sits insideneural networks. Not every ML system is deep learning, but every deep learning system is ML. That nesting is the key idea this module will sharpen into a three-level test you can apply to any feature.
Three Tests, One Nested Map
In plain wordsThe three tests work like a bouncer checking IDs at three doors: you only get through the next door if you pass the current one.
You have three terms — , , and — and they are not three separate things. They are nested categories, like a of boxes inside boxes.
To place any feature in the right box, ask three yes/no tests in order.
Does it act intelligently toward a goal? If yes → it is at least AI. If no → it is ordinary software (a calculator, a timer).
Does it improve by learning patterns from data? If yes → it is at least ML. If no → it is rule-based AI (a hand-coded like an if/else filter).
Does it learn through layered neural networks? If yes → it is DL. If no → it is ML but not DL (a decision tree, a spam filter).
Stop at the first 'no' — that is the smallest accurate label for the feature.
Photo Sorter has three features. Apply the three tests to each one and find the smallest accurate label.
Feature 1 — Date organiser
It reads the photo's timestamp and moves the file into a folder named by year. Test 1: does it act toward a goal? Yes — it organises photos. Test 2: does it learn from data? No — it follows a fixed rule (read date → sort). Label: AI only (rule-based).
Feature 2 — Blur classifier (simple)
It was trained on 200 labeled photos to score sharpness. Test 1: yes — it acts toward a goal. Test 2: yes — it learned a pattern from labeled data. Test 3: does it use layered neural networks? No — it uses a simple statistical model. Label: ML (not DL).
Feature 3 — Cat / dog / beach labeler
It passes raw pixels through a layered to produce a like 'cat' or 'beach'. All three tests pass. Label: Deep Learning — and therefore also ML and also AI.
Key insight: a DL feature is also ML and also AI. But an AI feature is NOT automatically ML or DL. The labels are cumulative going inward, not interchangeable.
AI, ML, and DL: Nested Zones
Each point is a Photo Sorter feature. Click a query to see which zone it belongs to — features that share a zone are close together. Notice DL points cluster deepest inside the ML zone, which itself sits inside AI.
How This Breaks: The 'All AI Is DL' Trap
In plain wordsCalling every AI feature 'deep learning' is like calling every vehicle a 'sports car' — technically it has an engine, but the label sets the wrong expectations.
The most common mistake is treating the three terms as synonyms. Many assume any AI feature must be deep learning. Here are three ways that breaks in practice.
Mislabeling a rule-based feature as 'AI-powered.' Photo Sorter's date organiser follows a fixed if/else rule. Calling it 'AI' misleads users about what it can learn or adapt.
Calling every ML feature 'deep learning.' The blur classifier learned from data but uses no neural network. Labeling it DL makes the system sound more complex and expensive than it is.
Assuming deep learning is always the right tool. DL needs far more data and compute than simple ML. If Photo Sorter has only 50 training photos, a neural network will perform worse than a plain statistical model.
Watch for: a product spec that says 'use AI' without specifying which level. Always ask the three tests. The answer changes the data you need, the cost, and the timeline.
Stop — attempt this before revealing. Photo Sorter is adding two new features. Apply the three tests yourself and write down the smallest accurate label for each. Hints: (1) 'learns from data' means it was trained on examples, not hand-coded. (2) 'layered neural network' means it stacks many transformation steps on raw inputs like pixels.
Feature A — Duplicate detector
It compares file checksums (a unique fingerprint of each file's bytes). If two checksums match, it flags the photos as duplicates. It never looks at image content and was never trained on examples.
Feature B — Face grouper (upgraded)
The team replaced the old face grouper with one that passes each face through 12 stacked transformation layers. This produces a numeric fingerprint, then clusters similar fingerprints together.
Reveal: answers and reasoning
Feature A — Duplicate detector: Test 1 (goal-directed)? Yes. Test 2 (learns from data)? No — it uses a fixed checksum rule. Label: AI only (rule-based). The key is test 2 — no training data means it cannot be ML.
Feature B — Upgraded face grouper: Test 1? Yes. Test 2 (learned from data)? Yes — it was trained to produce face fingerprints. Test 3 (layered neural network)? Yes — 12 stacked layers on raw face pixels. Label: Deep Learning. The upgrade added neural layers, which pushes it from ML to DL.
What the Labels Don't Cover Yet
You can now place any Photo Sorter feature in the right nested box: AI, ML, or DL. But notice that all three labels describe components — a classifier, a detector, a labeler. None describes a system that decides what to do next.
In the next module you will meet . These are systems that look at a goal, choose among actions, and loop until done. An agent is not a fourth box inside DL. It is a different architecture that can use the components you just classified.
Turn Photo Sorter into an album-making agent that chooses whether to label, search, ask you, or create a share link. You see why an agent is not simply a fourth inner box.
Explains what an agent is — a system that chooses actions in a loop — and shows how it differs from a model that only predicts.
In plain words — A model is like a vending machine that gives you one thing when you press a button; an agent is like a personal shopper who keeps making decisions until the whole job is done.
Why this matters: Knowing the agent/model distinction lets you correctly scope what Photo Sorter's album maker actually is and when to reach for each.
After this you'll be able to
Define an agent as a system that chooses actions toward a goal.
Explain how agents can use AI, machine learning, or deep learning models.
Distinguish a model that predicts from an agent that acts.
Decision this forces: Decide whether Photo Sorter's album maker is a model, an agent, or a model inside an agent.
Recap: The Three Nested Boxes
Stop and recall before reading on: Module 4 gave you three tests to classify any Photo Sorter feature. What are the three questions you ask, in order?
Answer from memory first, then check: (1) Does it act intelligently toward a goal? → AI. (2) Does it learn from data instead of following hand-written rules? → ML. (3) Does it use layered networks on raw inputs like pixels? → Deep Learning.
Those three nested boxes — ⊃ ⊃ — classify : things that take an input and return a . This module asks a harder question: what happens when a system doesn't just predict — it decides what to do next?
Agents Decide, Then Act
In plain wordsA model is like a vending machine — you press a button and it gives you one thing; an agent is like a personal shopper who looks at what you need, visits several stores, and comes back with a complete solution.
An is a system that looks at a goal, chooses an action, sees what happens, and then chooses again — repeating until the job is done.
stops after one step: input in, out.
loop: it can call (like search or file writers), read the result, and decide what to do next.
That loop is what makes an agent more than a fourth inner box.
It is a different shape of system — one that acts in the world, not just one that predicts a label.
An agent often uses a model as its brain, but the agent is the whole loop.
Your Photo Sorter app now has a new job: build a shareable beach album from this week's 20 photos, automatically.
A plain can't do this alone — it can only label one photo at a time and return a . It has no way to search, filter, ask you a question, or create a link. Those are actions, not predictions.
The album-maker works like this:
It calls the labeler (a tool) on all 20 photos and gets back labels.
It searches its label index for 'beach' and finds 14 matches.
It notices 3 of those 14 are blurry, so it asks you: 'Include blurry beach shots?'
You say no. It filters them out and creates a share link for the remaining 11 photos.
The deep-learning model is still doing the labeling — it lives inside the agent as one of its tools. The agent is the loop that decides when to call it and what to do with the result.
The Agent Loop, Step by Step
Each step feeds the next. The loop only stops when the agent decides the goal is met.
Use when
Use an agent when the task requires multiple steps, the steps can't be fully scripted in advance, and the system must choose what to do next based on what it observes.
Avoid when
Don't reach for an agent when a single prediction is enough — e.g. 'Is this photo blurry?' That's a model job. Adding an agent loop adds complexity with no benefit.
Rule of thumb
If you can write every step down before the app runs, you need a model (or plain code). If the steps depend on what the app discovers along the way, you need an agent.
When Agents Go Wrong
Three ways the album agent breaks in practice
Calling the wrong tool repeatedly. The agent labels the same 20 photos three times instead of moving on. You see the album never appears and the app stalls. Cause: the agent's decision logic has no memory of what it already did.
Treating a model's prediction as a final decision. The labeler says 'beach' with 60% confidence, and the agent adds the photo without checking. You get a sunset-in-a-parking-lot in your beach album. Cause: the agent trusted a weak prediction instead of asking you.
Confusing a scripted pipeline for an agent. You hard-code 'label → filter → share' in that exact order, every time. When all photos are blurry the app still creates an empty album and shares it. A real agent would notice the empty result and ask what to do next.
Watch for: an agent that never asks a clarifying question is probably a scripted pipeline wearing an agent label.
Stop — attempt this before revealing the answer. Read the partial agent plan below. One action is missing. Fill it in before you scroll.
Scenario: the user asks Photo Sorter to 'make a birthday album from last month's photos.' Here is the agent's plan with one step left blank:
Call the deep-learning labeler on all photos → get labels.
Search labels for 'birthday', 'cake', 'candles' → find 8 matches.
Check each match for blur → 2 are blurry.
??? ← What should the agent do here before creating the album?
Create the album and return a share link.
Hint 1: the agent has already found a problem (blurry photos). Hint 2: think about what makes an agent different from a fixed script.
Answer: Step 4 should be — Ask the user: 'I found 2 blurry birthday photos. Include them or skip them?' This is the step that makes it an agent, not a pipeline. A fixed script would silently skip or silently include them. The agent observes a problem and chooses to involve you before acting. That decision-under-uncertainty loop is the defining move.
What You Can Now Classify
You can now place any Photo Sorter feature into the right box.
A blur detector is a (one prediction, then stops).
The labeler is (layers on pixels).
The album maker is an (a loop that chooses actions toward a goal).
An agent is not a fourth inner box inside deep learning.
It is a different shape entirely — a loop that can use any of the three boxes as tools.
The next module puts this all together.
You'll audit every Photo Sorter feature for the most common labeling mistakes.
Examples: calling every loop an agent, or every AI system deep learning.
Then practice the full taxonomy before the solo capstone task.
Audit Photo Sorter for common labeling mistakes, like calling every chatbot an agent or every AI system deep learning. You prepare for the solo task by classifying partly worked examples yourself.
A hands-on audit of Photo Sorter that catches and fixes the most common AI, ML, deep learning, and agent labeling mistakes.
In plain words — Like checking that every item in your toolbox is labeled correctly before you start a repair job — a screwdriver mislabeled as a drill will send you looking in the wrong place when something goes wrong.
Why this matters: Knowing the right label stops you from building the wrong solution — wrong labels lead to wrong fixes, wrong expectations, and wrong architecture.
After this you'll be able to
Catch incorrect AI, machine learning, deep learning, and agent labels.
Justify a classification using the nested map.
Test your own taxonomy with concrete examples.
Recap: Why Agents Sit Outside the Boxes
In plain wordsThe nested boxes are like Russian dolls — deep learning fits inside machine learning, which fits inside AI — but an agent is the hand that picks up and uses the dolls, not a doll itself.
Before reading on, predict from memory: Module 5 said an agent is NOT simply a fourth inner box inside deep learning. Why not? Write your answer in one sentence, then scroll down.
Answer: is a system that decides and acts in a loop. It can wrap any kind of (or none at all). The nested map shows what a system learns from; an agent describes how a system behaves. Those are different questions. The agent sits beside the map, not inside it.
Photo Sorter has grown into a real product with several parts. Do all those parts carry the right label? You're about to audit them and fix the ones that don't.
The Three Mix-Ups That Fool Everyone
In plain wordsCalling every AI system 'deep learning' is like calling every vehicle a 'Formula 1 car' — technically a car, but wildly wrong about what's under the hood.
Three labeling mistakes show up again and again in professional teams.
"It uses AI" when it's really rule-based. A follows hand-written if/then logic. No learning. No . Calling it overstates what it does.
"It uses deep learning" when it's really . Not every learned model is a . A decision tree or simple classifier is ML, not .
"It's an agent" when it's really a single-shot model call. An runs a decide-act-observe loop. A chatbot that answers once and stops is not an .
The fix is always the same. Ask the three tests from Module 4: does it act intelligently? Does it learn from data? Does it use layered networks? Then ask the agent question from Module 5: does it loop, decide, and act on its own?
Below are four Photo Sorter components with the labels a developer first gave them. Before reading the verdict, decide for yourself: right or wrong?
"The blur filter is an AI feature." → Wrong. It uses a fixed pixel-contrast formula with no learning. Correct label: .
"The duplicate finder uses deep learning." → Wrong. It was trained on data (so it is ), but it uses a simple similarity score, not a layered . Correct label: machine learning.
"The image labeler is a machine learning model." → Technically true but incomplete. It is also because it uses a multi-layer neural network on raw pixels. The more precise label is deep learning (which is a subset of ML).
"The album-making chatbot is an agent." → Depends. If it answers once and stops, it is just a model call — not an . If it loops, picks tools, and acts until the album is done, it is an agent.
Stop — attempt this before revealing. Read each description, write your label and one-sentence justification, then check the answer below. Hints: (1) ask the three tests in order — learn? layers? loop? (2) 'AI' alone is never a complete answer.
Part A — Location tagger
Photo Sorter reads GPS coordinates from each photo's file header. It writes a city name next to the photo using a lookup table of coordinate ranges mapped to city names. No training data was used.
Part B — Scene ranker
Photo Sorter scores each photo for 'visual quality' using a model trained on 50,000 human-rated photos. The model takes raw image pixels as input. It passes them through 12 layers of learned filters. It outputs a score from 0 to 10.
Answers
Part A → Rule-based system. It follows a fixed lookup table with no learning and no . Calling it would be the first mix-up from the list above.
Part B → (and therefore also ML and ). It was trained on data (ML ✓). It uses 12 layers of learned filters on raw pixels ( ✓). The most precise label is . Saying only 'ML' would be the second mix-up — technically true but imprecise.
You've now audited Photo Sorter end to end. The solo capstone asks you to classify a new system from scratch. Justify every label with the nested map. You have everything you need.
Where Each Photo Sorter Part Lives
Each point is one Photo Sorter component. Click a label on the right to highlight the nearest components and see why they share that category. Points that sit close together share the same 'what it learns from' answer.
Auditing Photo Sorter Step by Step
Ask: does it learn from data?
Start with the simplest test. Photo Sorter's blur filter checks pixel contrast with a fixed formula — no , no . Label: , not AI. The date sorter is the same — pure logic, no learning.
Ask: does it use layered networks?
The duplicate-photo finder was trained on labeled pairs, so it is . But it uses a simple similarity score, not a — so it is NOT . The image labeler reads raw pixels through many layers to output 'cat' or 'beach' — that IS deep learning.
Ask: does it loop, decide, and act?
The album-making agent checks labels, decides whether to search for more photos, asks you a question, or creates a share link — then repeats. That loop makes it an . A chatbot that just answers 'Here are your beach photos' once and stops is not an agent — it is a single call.
Fix the label, then justify it
A correct label always comes with a one-sentence reason tied to the nested map. 'This is deep learning because it learns from pixel data through multiple layers' is a justified label. 'This is AI' alone is not — it skips the why.
How Taxonomy Mistakes Break Real Projects
Wrong labels cause real damage — not just confusion.
Calling a rule-based filter 'AI' raises false expectations. When the blur filter misses a dark photo, users blame 'the AI' and lose trust. The real problem is a fixed threshold, not a model.
Calling a simple ML model 'deep learning' leads to wrong fixes. A team thinking their duplicate finder is a neural network will add layers when accuracy drops. The real fix is better data or a different metric.
Calling a single model call 'an agent' sets wrong architecture. A developer thinking a one-shot chatbot is an agent will skip the decide-act-observe loop. The system will silently fail on multi-step tasks.
Putting it together
Synthesis
Before looking back, redraw the nested boxes from memory and place Photo Sorter's features inside them. Then add the agent card and explain why it connects to the boxes instead of becoming the deepest box.
Decide whether Photo Sorter's labeler is using rules, machine learning, or both.
Decide when Photo Sorter's learned labeler should be called deep learning instead of general machine learning.
Decide the smallest accurate label for each Photo Sorter feature.
Decide whether Photo Sorter's album maker is a model, an agent, or a model inside an agent.
Decide whether each Photo Sorter component has the right label and fix any wrong one.
Try it:
Apply what you learned to AI vs ML vs Deep Learning.
A thermostat turns the heat on when the temperature drops below 68°F and off when it rises above 72°F. Does this system belong inside the artificial intelligence box?
Artificial intelligence covers systems that simulate intelligent, goal-directed behavior in ways that go beyond rigid if-then rules. A thermostat's behavior is entirely captured by two fixed thresholds — there is nothing to adapt, learn, or reason about. Sensing an environment alone does not make a system AI (wrong option 2), and automation is far broader than AI (wrong option 3). Internet connectivity is irrelevant to the definition (wrong option 4).
A photo-labeling system was built by an engineer who wrote out every rule: 'if the image is mostly blue and has a horizon line, label it outdoor.' A second system was shown 50,000 labeled photos and figured out its own patterns. Which statement correctly classifies these two systems?
Machine learning is specifically the subset of AI where the system derives its behavior from training data rather than hand-coded rules. The first system is AI (it does something intelligent) but not ML (its rules were written by a human). The second is ML by definition. Option 3 conflates ML and deep learning — deep learning is a subset of ML, not a synonym. Option 4 applies a philosophical bar ('understanding') that is not part of the practical definition of AI.
Look at this description of two classifiers:
Classifier A: uses a decision tree with 12 hand-tuned branches.
Classifier B: passes pixel values through five learned layers of weights.
Which one should be called deep learning, and why?
Deep learning is defined by the use of a neural network: multiple layers that progressively transform numerical inputs into outputs. Classifier B matches that description exactly. Classifier A is machine learning but not deep learning — decision trees do not use layered weight transformations. Option 3 repeats the common mistake of treating all trained models as deep learning. Option 4 invents a layer-count threshold that does not exist in the definition.
Photo Sorter's album maker receives the labels produced by the photo labeler, then repeatedly chooses which album to place each photo in, checks whether the resulting album looks coherent, and adjusts its choices to reach a goal of 'well-organized albums.' Is the album maker best described as a model, an agent, or a model inside an agent?
An agent is defined as a system that chooses actions toward a goal, not merely one that maps inputs to outputs. The album maker selects placements, evaluates coherence, and adjusts — that is the action-evaluate-adjust loop that defines an agent. Option 1 describes a passive model, which does not loop or adjust. Option 3 would be correct if the decision loop were external, but here the album maker itself contains the loop. Option 4 confuses specific agent applications with the general definition.
A colleague says: 'Our product uses deep learning, so it's a completely different category from AI — deep learning is more advanced than AI.' Identify the two taxonomy mistakes in that statement and correct them.
Reference answer: Mistake 1: deep learning is not a separate category from AI — it is a subset of machine learning, which is itself a subset of AI. All deep learning is AI. Mistake 2: 'more advanced' does not mean 'outside' the AI category — the nesting goes AI contains ML contains deep learning, so deep learning is the most specific level, not a different box entirely.
The nested map is: AI is the outermost box, machine learning sits inside it, and deep learning sits inside machine learning. Saying deep learning is separate from AI inverts or ignores this containment. Saying it is 'more advanced than AI' confuses specificity with separation — being a narrower, more specialized technique does not place it outside the broader category.
Provenance
Sources
AI Data Analyst Course Track · knowledge base · 2026-06-22