Types of AI & AI Agents
There are two ways to classify AI systems. They answer completely different questions and it's easy to confuse them.
The first asks: "How capable is this AI?" — Narrow AI, General AI, Superintelligent AI. These are about scope. Can it do one thing brilliantly? Can it do anything a human can?
The second asks: "How does this AI process information?" — Reactive machines, Limited memory, Theory of mind, Self-aware. These are about architecture. Does it remember anything? Can it understand human intentions?
Both taxonomies matter. A system can be Narrow AI with Limited Memory (like a self-driving car). Or Narrow AI that's Reactive (like Deep Blue playing chess). Understanding both lets you predict what an AI will do well and where it'll fail.
Why two taxonomies exist
Capability: How intelligent is it?
This axis measures the breadth and generality of what an AI can do.
Narrow AI (Weak AI)
Every AI system that exists today. Extraordinarily good at one specific task or a narrow range of tasks. Completely useless outside that domain.
GPT-4 writes better essays than most humans. It cannot drive a car, diagnose diseases, or play chess better than stockfish (a chess engine is a different AI, trained for a different task). AlphaGo beat every human at Go. It cannot recognise a cat or write a sentence. Tesla's Autopilot navigates highways. It cannot cook or make medical decisions.
Narrow AI is not a limitation of current technology — it's a fundamental architectural choice. We optimise for one task because optimising for everything is harder.
General AI (Strong AI)
A theoretical system capable of performing any intellectual task a human can, across any domain. Could learn to drive, then learn to write, then learn medicine — with the ability to transfer knowledge between domains.
Does not exist. Active research. Timeframe estimates range from "10 years away" (some optimists at major labs) to "never" (many safety researchers) depending on who you ask and what assumptions they make.
Superintelligent AI (Super AI)
Hypothetical AI that surpasses human intelligence across every domain simultaneously. Not just "good at chess," but "better at everything than any human has ever been."
This is thought experiment territory. Worth knowing about because it defines why organisations like Anthropic and DeepMind have entire teams focused on alignment and safety — the bet is that if superintelligence ever emerges, you'd rather it be aligned with human values before it's powerful.
Functionality: How does it process information?
This axis describes the system's architecture and memory structure.
Reactive Machines
These systems operate purely on current input. No memory of the past. No internal model of the world. They respond to stimuli with fixed outputs based on pattern matching.
IBM's Deep Blue evaluates a chess board position using rules and pattern recognition. It doesn't "remember" previous games. If you show it the same position twice, it makes the same decision. Efficient, predictable, but brittle — can't adapt to novel situations.
Modern examples are rare because reactive systems are too limited. But rule-based fraud detection is close — it fires on fixed patterns.
Limited Memory
These use historical data to improve current decisions. They maintain some model of state or context. Most modern AI systems are here.
Self-driving cars observe the last few seconds of traffic — are you accelerating? Is the car ahead braking? Use that recent history to decide whether to speed up or slow down. A chatbot remembers the conversation so far — it knows you asked about returns in the first message — so when you ask "how long does it take?" the AI interprets it as referring to returns, not delivery times.
Limited memory systems can adapt and improve, but they have recency bias and finite context windows. They can't understand patterns that play out over months or years.
Theory of Mind
Theoretical. An AI that models human beliefs, intentions, emotions, and knowledge. Would understand not just *what* you said but *why* you said it and what you're likely feeling.
Potential application: a robot in healthcare that adapts its communication based on whether a patient is anxious or confident. Or a negotiation AI that understands the opponent's actual constraints, not just their stated position.
Current AI simulates this (sentiment analysis, intent classification) but doesn't actually do it. We can measure whether an LLM gets the right answer on psychology tests; we can't know if it truly *understands* human psychology.
Self-Aware AI
Hypothetical. AI with genuine consciousness, self-awareness, and an understanding of its own existence. Could reflect on itself, have preferences about its own future, experience something like emotions.
Pure philosophy territory. We have no idea if this is even possible or desirable. Matters for AI safety theory (would a self-aware superintelligence cooperate with humans?) but not for engineering today.
AI Capability vs Functionality — the matrix
| Narrow AI | General AI | Superintelligent AI | |
|---|---|---|---|
| Reactive | Chess engine (Deep Blue) | Hypothetical reactive AGI | Not researched |
| Limited Memory | ChatGPT, self-driving cars, recommendation engines | Hypothetical — AGI with memory but no introspection | Hypothetical superintelligence with only reactive response |
| Theory of Mind | Modern LLMs simulate it, don't do it | Hypothetical — truly understands human intention across domains | Superintelligence + understanding of human minds |
| Self-Aware | Not possible (by definition) | Hypothetical AGI with consciousness | Conscious superintelligence — the AI safety nightmare/dream scenario |
Common mistake: conflating the taxonomies
What is an AI Agent?
An agent is a system that perceives its environment, processes information, and takes actions to achieve specific goals. It operates with some degree of autonomy — it doesn't need a human telling it what to do at every step.
A thermostat is an agent (it perceives temperature, decides whether to heat/cool, takes action). A chess engine is an agent (it perceives the board, decides on a move, plays it). An autonomous vehicle is an agent (it perceives roads/obstacles, decides on speed/direction, controls the car).
Agents are defined by a few core traits:
Autonomous — act without constant human input. A delivery robot decides its own path. It doesn't get told "go left, now go right, now stop" — it figures it out from goals and constraints.
Goal-Driven — optimise for defined objectives. A logistics AI balances multiple conflicting goals: deliver fast (speed), save money (fuel efficiency), satisfy constraints (regulations, load limits).
Perceptive — gather data from sensors, APIs, user input, or other systems. A security agent monitors network traffic. A sales agent reads customer emails. A robot reads visual input from cameras.
Adaptable — adjust strategy when situations change. A navigation app reroutes when traffic appears. A learning agent improves over time based on feedback.
Collaborative — work with humans or other agents. A medical diagnosis agent works with doctors. A warehouse fleet of robots coordinate to avoid collisions and optimise tasks.
Six types of AI agents
Agents are classified by how they make decisions and what information they use.
Simple Reflex Agents
These act only on current perception. No memory, no internal model. They follow "if X then Y" rules.
A traffic light controller that changes signals based on fixed timing. If it's been 60 seconds on red, switch to green. It doesn't model traffic flow or learn from patterns. It just implements rules. Reliable and simple but can't adapt.
Model-Based Reflex Agents
These maintain an internal model of the world. They infer missing information from partial observations.
A robot vacuum maps the room, remembers which areas it's cleaned, infers the layout from sensor data. Even if it loses direct vision of a wall, it knows the wall is there because it built a model of the room. Can handle situations where information is incomplete.
Goal-Based Agents
These choose actions by evaluating how well they move toward a goal. They plan ahead.
A route-planning AI trying to get from A to B considers multiple paths, evaluates which gets there fastest (given current traffic), and adapts when conditions change. It doesn't just react to the next intersection — it thinks about the whole journey.
Utility-Based Agents
These go beyond "achieve goal" and ask "how good is this outcome?" They optimise using a utility function that measures satisfaction.
A financial portfolio manager doesn't just "make profit" — it balances risk vs return. Different investors have different utility functions. One wants safe growth, one wants aggressive returns. The agent uses the utility function to pick the best option.
Learning Agents
These improve over time by reflecting on their own performance. They learn from experience, updating their internal models to make better decisions.
A customer service chatbot improves response accuracy over time by learning from previous interactions. Was this response helpful? The feedback updates the model. Next time it sees a similar query, it performs better. The learning loop is built in.
Multi-Agent Systems (MAS)
Multiple autonomous agents interact in a shared environment. They may cooperate, compete, or both.
A warehouse with 50 robots. Each robot is a learning agent that improves its navigation. They cooperate (coordinate to avoid collisions, balance workload) and compete (getting to the highest-value tasks first). The system as a whole is more robust than any single agent — if one fails, others compensate.
Six types of AI agents — how they perceive and decide
| Agent type | Perceives | Decides by | Real-world example |
|---|---|---|---|
| Simple Reflex | Current state only | Condition-action rules | Thermostat, spam filter |
| Model-Based Reflex | Current state + internal model | Rules + world model | Roomba with obstacle map |
| Goal-Based | State + goal | Search/planning towards goal | Navigation apps |
| Utility-Based | State + goal + preferences | Maximise utility function | Game-playing AI |
| Learning | State + feedback | Improve policy over time | AlphaGo, recommendation engines |
| Multi-Agent | State + other agents | Coordination/competition | Auction bots, traffic control |
# Simple reflex agent: vacuum cleaner with fixed rules
# Perceives: is the current square dirty? Is there a wall?
# Acts: move, suck dirt
class SimpleReflexVacuum:
"""Vacuum that follows if-then rules. No memory, no planning."""
def __init__(self):
self.location = 'A' # Start in room A
def perceive(self, grid):
"""What do I see right now?"""
return {
'current_location': self.location,
'is_dirty': grid[self.location]['dirty'],
'adjacent_rooms': grid[self.location]['adjacent']
}
def decide(self, perception):
"""Simple if-then rules. No memory, no learning."""
if perception['is_dirty']:
return 'suck' # If dirty, clean it
elif len(perception['adjacent_rooms']) > 0:
return 'move' # If clean, move to adjacent room
else:
return 'idle' # No adjacent rooms, stay
def act(self, action, grid):
"""Execute the action."""
if action == 'suck':
grid[self.location]['dirty'] = False
print(f"Sucked dirt at {self.location}")
elif action == 'move':
next_room = grid[self.location]['adjacent'][0]
self.location = next_room
print(f"Moved to {self.location}")
# Example: a simple 2-room grid
grid = {
'A': {'dirty': True, 'adjacent': ['B']},
'B': {'dirty': True, 'adjacent': ['A']}
}
vacuum = SimpleReflexVacuum()
for step in range(6):
perception = vacuum.perceive(grid)
action = vacuum.decide(perception)
vacuum.act(action, grid)
print(f"Step {step}: action={action}, location={vacuum.location}\n")
# Output:
# Step 0: action=suck, location=A
# Step 1: action=move, location=B
# Step 2: action=suck, location=B
# Step 3: action=move, location=A
# Step 4: action=idle, location=A
# (keeps alternating between A and B because it has no memory of what it already cleaned)Why the simple reflex agent fails
class LearningVacuum:
"""Vacuum that learns from experience. Remembers which rooms are clean."""
def __init__(self):
self.location = 'A'
self.cleaned_history = set() # Memory: rooms I've already cleaned
def perceive(self, grid):
"""What do I see and remember?"""
return {
'current_location': self.location,
'is_dirty': grid[self.location]['dirty'],
'adjacent_rooms': grid[self.location]['adjacent'],
'cleaned_rooms': self.cleaned_history # My memory
}
def decide(self, perception):
"""Smarter if-then rules using memory."""
if perception['is_dirty']:
return 'suck' # If dirty, clean it
# Prefer moving to rooms I haven't cleaned yet
uncleaned = [r for r in perception['adjacent_rooms']
if r not in perception['cleaned_rooms']]
if uncleaned:
self.location = uncleaned[0]
return 'move'
# If all adjacent rooms are cleaned, stay
return 'idle'
def act(self, action, grid):
"""Execute and update memory."""
if action == 'suck':
grid[self.location]['dirty'] = False
self.cleaned_history.add(self.location) # Remember: cleaned this room
print(f"Sucked dirt at {self.location}")
elif action == 'move':
self.location = self.location
print(f"Moved to {self.location}")
# Same grid
grid = {
'A': {'dirty': True, 'adjacent': ['B']},
'B': {'dirty': True, 'adjacent': ['A']}
}
vacuum = LearningVacuum()
for step in range(6):
perception = vacuum.perceive(grid)
action = vacuum.decide(perception)
vacuum.act(action, grid)
print(f"Step {step}: action={action}, location={vacuum.location}, cleaned={vacuum.cleaned_history}\n")
# Output:
# Step 0: action=suck, location=A, cleaned={'A'}
# Step 1: action=move, location=B, cleaned={'A'}
# Step 2: action=suck, location=B, cleaned={'A', 'B'}
# Step 3: action=idle, location=B, cleaned={'A', 'B'}
# (stops because both rooms are clean — memory prevents useless wandering)Where agents show up in real systems
You interact with agents constantly, and they're getting more sophisticated.
Recommendation agents learn your preferences and suggest what you might like (Netflix, Spotify, TikTok). They're learning agents with limited memory — they remember your history and improve their recommendations.
Autonomous vehicles are goal-based learning agents. Goal: reach destination safely. Perception: cameras, lidar, radar. Limited memory: recent sensor data and maps. Learning: improve driving models from real-world data.
Supply chain optimisation agents are utility-based multi-agent systems. Multiple agents (warehouse, logistics, production) coordinate. Each has conflicting goals (warehouse wants to minimise storage, logistics wants to minimise transit). The system finds a utility balance.
Chatbots range from simple reflex (if user says "hello" return greeting) to learning agents that improve responses based on user satisfaction.
The trend is clear: real systems have moved from reactive to learning agents because learning agents are more useful. They remember context, improve over time, and adapt to change. If a system is purely reactive, it's either because the domain is simple enough or because it was built a while ago.
What's next
Now you know the landscape: AI can be narrow or general, and it can be reactive or have memory. You know agents are systems that perceive, decide, and act.
The next module goes deeper into how agents actually decide — problem solving, search algorithms, and optimisation. You'll see how a goal-based agent figures out what path to take, what a utility function actually looks like, and why some search strategies beat others.
From there, we get into the math: how individual neurons work, how they're stacked into networks, and how those networks learn. The foundations for everything from vision systems to LLMs.
I build these systems professionally.
Whether it's a RAG pipeline, analytics migration, or AI workflow — let's talk.