Define and classify AI agents according to established taxonomies...

Q: In an exam scenario, what makes a classification answer for an AI agent “complete” rather than a label-only response?

A complete classification answer links observable behavior to the claimed category by explaining: What the system’s goal is (what it is trying to achieve, if goal-directed). How it represents the current situation What information it keeps/maintains about observations and context. How it selects actions How its decisions/actions are chosen to move it toward the goal (not just naming the category).

Q: Distinguish a traditional program , a one-turn chatbot , and an AI agent by their control/interaction pattern.

Traditional program Follows a predetermined control flow and usually needs code changes to handle new situations. One-turn chatbot Generates an answer to a prompt but does not necessarily maintain state, choose subsequent actions, or change its environment. AI agent Repeatedly observes, decides, and acts, then uses the result of its action to select what to do next.

Q: Why is the claim “It uses GPT, so it is an agent” incorrect, and what should determine whether something is an agent?

The claim is incorrect because agency depends on the system’s architecture and behavior , not the model name (“GPT”). To decide if something is an agent, focus on whether it repeatedly observes, decides, acts and uses action results to choose what to do next. Start classification from perception-action behavior rather than branding.

Q: Why is the statement “Any system with an input and output is an agent” considered too broad?

It is too broad because an input-output mapping can be a fixed classifier that lacks meaningful autonomy or goal-directed action . An agent is expected to have the structural basis of receiving observations, choosing actions, and (typically) interacting with an environment over time, not merely producing outputs.

Q: Precisely distinguish a model-based agent from a goal-based agent .

Model-based agent Represents the world (maintains a model of the environment/state). Goal-based agent Is model-based and additionally reasons about how to reach a desired future state (a goal).

Q: Does an AI agent have to be fully autonomous? State the course’s position and its implication for classification.

No. Agency exists on a spectrum. A system may still count as an agent even if it asks for approval before taking risky actions. So “not fully autonomous” does not automatically disqualify a system from being classified as an agent.

Q: Can an AI system belong to only one agent category? Explain the expected exam-safe stance.

Not necessarily. Modern systems can combine several types , so an agent may fit multiple categories at once. Because behavior can include rules, internal state, goals, preferences, and adaptation, categories (e.g., in Russell and Norvig-style thinking) can overlap in modern systems. In an exam, show this by explaining the links between observed behaviors and each relevant category, rather than forcing exactly one label.

Q: When defining and classifying an AI agent, what features indicate it has the “structural basis” of an agent (as opposed to branding)?

A system has the structural basis of an agent if it: Receives observations . Maintains relevant information (state/context needed for decisions). Chooses actions (decides what to do, not just outputs text). Changes or responds to its environment , using outcomes to inform what it does next.

Q: In AI agent design, what is the perception-action loop , and what are its core stages?

The perception-action loop is the repeating cycle through which an agent interacts with its environment: the environment provides information, the agent processes it, and the agent acts in a way that may change the environment, producing new information for the next cycle. Environment The world or software system in which the agent operates. Perceive Receive observations via sensors, APIs, files, messages, or user input. Think Interpret observations and decide what should happen next. Act Use an actuator, tool, or software operation. Changed environment Observe the new situation and repeat the cycle.

Q: Using the perception-action loop, what evidence would you give to justify that a system is an AI agent (rather than a static program that returns one predetermined output)?

Show that the system repeatedly perceives , reasons , and acts , then uses the consequences of its actions as new information for later decisions. The key evidence is a cycle : later actions are selected based on earlier observations (including observations that result from the system’s own actions). This supports autonomy : the system is not limited to producing a single output and stopping; it updates what it does next based on what happened after the previous action.

In an exam scenario, what makes a classification answer for an AI agent “complete” rather than a label-only response?

A complete classification answer links observable behavior to the claimed category by explaining:

What the system’s goal is (what it is trying to achieve, if goal-directed).
How it represents the current situation
- What information it keeps/maintains about observations and context.
How it selects actions
- How its decisions/actions are chosen to move it toward the goal (not just naming the category).

Distinguish a traditional program, a one-turn chatbot, and an AI agent by their control/interaction pattern.

Traditional program
- Follows a predetermined control flow and usually needs code changes to handle new situations.
One-turn chatbot
- Generates an answer to a prompt but does not necessarily maintain state, choose subsequent actions, or change its environment.
AI agent
- Repeatedly observes, decides, and acts, then uses the result of its action to select what to do next.

Why is the claim “It uses GPT, so it is an agent” incorrect, and what should determine whether something is an agent?

The claim is incorrect because agency depends on the system’s architecture and behavior, not the model name (“GPT”).

To decide if something is an agent, focus on whether it repeatedly observes, decides, acts and uses action results to choose what to do next.
Start classification from perception-action behavior rather than branding.

Why is the statement “Any system with an input and output is an agent” considered too broad?

It is too broad because an input-output mapping can be a fixed classifier that lacks meaningful autonomy or goal-directed action.

An agent is expected to have the structural basis of receiving observations, choosing actions, and (typically) interacting with an environment over time, not merely producing outputs.

Precisely distinguish a model-based agent from a goal-based agent.

Model-based agent
- Represents the world (maintains a model of the environment/state).
Goal-based agent
- Is model-based and additionally reasons about how to reach a desired future state (a goal).

Does an AI agent have to be fully autonomous? State the course’s position and its implication for classification.

No. Agency exists on a spectrum.

A system may still count as an agent even if it asks for approval before taking risky actions.
So “not fully autonomous” does not automatically disqualify a system from being classified as an agent.

Can an AI system belong to only one agent category? Explain the expected exam-safe stance.

Not necessarily. Modern systems can combine several types, so an agent may fit multiple categories at once.

Because behavior can include rules, internal state, goals, preferences, and adaptation, categories (e.g., in Russell and Norvig-style thinking) can overlap in modern systems.
In an exam, show this by explaining the links between observed behaviors and each relevant category, rather than forcing exactly one label.

When defining and classifying an AI agent, what features indicate it has the “structural basis” of an agent (as opposed to branding)?

A system has the structural basis of an agent if it:

Receives observations.
Maintains relevant information (state/context needed for decisions).
Chooses actions (decides what to do, not just outputs text).
Changes or responds to its environment, using outcomes to inform what it does next.

In AI agent design, what is the perception-action loop, and what are its core stages?

The perception-action loop is the repeating cycle through which an agent interacts with its environment: the environment provides information, the agent processes it, and the agent acts in a way that may change the environment, producing new information for the next cycle.

Environment
- The world or software system in which the agent operates.
Perceive
- Receive observations via sensors, APIs, files, messages, or user input.
Think
- Interpret observations and decide what should happen next.
Act
- Use an actuator, tool, or software operation.
Changed environment
- Observe the new situation and repeat the cycle.

Using the perception-action loop, what evidence would you give to justify that a system is an AI agent (rather than a static program that returns one predetermined output)?

Show that the system repeatedly perceives, reasons, and acts, then uses the consequences of its actions as new information for later decisions.

The key evidence is a cycle: later actions are selected based on earlier observations (including observations that result from the system’s own actions).
This supports autonomy: the system is not limited to producing a single output and stopping; it updates what it does next based on what happened after the previous action.

A coding system can (1) read a file, (2) edit a function, (3) run the test suite, (4) observe a failure, (5) revise the code, and (6) run tests again. Explain how this demonstrates the perception-action loop, including what counts as a percept and what counts as an action.

This sequence demonstrates a repeating perceive → think → act → changed environment → perceive cycle.

Percepts (observations)
- Reading the repository/file contents.
- Test results (e.g., a failure) after running the test suite.
Actions
- Editing files / revising code (a software operation).
- Running the test suite (using a tool/software operation).
Why it matters
- The test result is a new percept that influences the next action (revising code and rerunning tests).

In AI agents, what does autonomy mean, and how does it differ from a system like a web server that responds automatically?

Autonomy means the system decides at least some of its next actions without a human prescribing every step, including making choices at runtime about what to do next.

Autonomous agent: can choose its next operation at runtime (not fully pre-specified).
Web server (contrast case): may respond automatically, but its response is normally determined by predefined program logic rather than runtime choice about the next action.

What is the agent decision-function form that maps observation history to an action, and what does it conceptually imply about “state”?

An agent’s action at time t can be modeled as:

f(percept₁, percept₂, …, percept_t) → action_t

Conceptually, this implies the agent can base its decision on the history of observations (a form of internal “state”), rather than only the current input, when selecting action_t.

Why can an agent’s history of observations be important for choosing an action, rather than relying only on the current observation?

The history matters because the current observation may be incomplete.

An agent can use earlier observations to infer information that is not currently visible.
This supports better action selection when the present percept does not contain all relevant details.

Classify AI systems by low, moderate, and high agency, and give the defining example behavior for each.

Low agency:
- A spell-checker corrects a word immediately according to fixed rules.
Moderate agency:
- A writing assistant proposes structural changes while preserving the user’s control.
High agency:
- A coding assistant decides which files to inspect, edits them, runs tests, and iterates until the requested task is complete.

When distinguishing an AI agent from a traditional program, what two features should you focus on, and how do they separate a fixed spell-checker from an autonomous coding assistant?

Focus on autonomy and state (use of observation history).

Fixed spell-checker (traditional program): maps an input to a correction through predetermined logic.
Autonomous coding assistant (agent): uses a history of observations to choose its next operation and can adapt its sequence of actions without direct instructions for every step.

Because it can select and adapt actions at runtime using state/history, the coding assistant has substantially more agency and qualifies more clearly as an agent.

In AI system design, what is an LLM, and why is an LLM by itself not necessarily an AI agent?

An LLM (large language model) is a language model that generates or interprets text. It can serve as the reasoning component inside an agent, but the LLM alone is not necessarily an agent because agency depends on the surrounding architecture, not just the model.

An LLM alone may simply transform an input into an output (e.g., single classification or single-turn response).
An agent requires an architecture that supports a continuing loop involving observations, state, goals, and actions.

Using the “one-turn chatbot” criterion, when is a chatbot generally a tool rather than an agent, and what makes it more agentic?

A chatbot that answers a question in a single turn is generally a tool, not an agent, because it only transforms an input into an output.

It becomes more agentic when it:
- maintains state,
- decides what to do next,
- uses actions that affect an environment, and
- pursues a goal over multiple steps.

Classify each LLM application as “non-agentic” or “agentic,” and justify briefly based on its architecture: (1) GPT classifies an email as spam/not spam and returns the label. (2) GPT monitors an inbox, identifies messages requiring action, drafts replies, checks a calendar, asks for approval when necessary, and sends or schedules messages.

(1) Non-agentic
- It performs a single-step transformation (classification) and returns an output label.
(2) Agentic
- It operates over multiple steps in a continuing process: it monitors (ongoing observation), identifies needed actions, drafts replies, checks a calendar, asks for approval, and then sends or schedules messages (actions affecting an environment).

If two systems use the same underlying GPT model, what determines whether one system is an agent and the other is not?

Whether the system is an agent is determined by the surrounding architecture, not the underlying model.

The underlying model can be identical in both systems.
An agent is characterized by autonomous multi-step interaction with an environment using a loop of observations, state, goals, and actions.
GPT usage alone does not establish agency.

You must decide whether an LLM application is an agent. What should you examine, and what specific architectural pattern indicates agency (as contrasted with a one-turn input→output tool)?

You should examine the architecture rather than the model’s capability.

One-turn tool pattern: the system only transforms an input into an output.
Agent pattern: the system runs a continuing loop that uses:
- observations,
- state,
- goals, and
- actions (that affect an environment),
and it pursues a goal over multiple steps.

What is an expert system, and what is the typical form of knowledge representation it uses?

An expert system is a rule-based program that encodes human expertise as explicit if-then rules.

Core idea: represent expert knowledge as rules that map conditions to conclusions/actions (e.g., “IF fever AND stiff neck ⇒ suspect meningitis”).
Implication: the system’s behavior is driven by applying these hand-written rules to inputs.

Name three classic examples of expert systems and state what each was used for.

Three examples are:

MYCIN
- Diagnosed bacterial infections.
XCON
- Configured computer orders.
DENDRAL
- Helped identify molecular structures.

Why were expert systems considered valuable, and what were their main limitations?

Expert systems were valuable because their reasoning was:

Deterministic
Explainable
Specialized

Their main limitations were:

Brittleness (they struggled with unfamiliar situations)
High manual effort to encode many rules, known as the knowledge bottleneck

What is the knowledge bottleneck in expert systems?

The knowledge bottleneck is the problem that expert systems require experts to manually encode large numbers of rules.

This creates a scaling barrier: the system’s competence depends on how much explicit rule knowledge can be written and maintained.

Compare an expert system to an LLM-based system in how knowledge is obtained, and state what they share.

Expert system
- Knowledge is manually encoded as explicit rules.
LLM-based system
- Broad patterns and information are learned from large text collections during pre-training.
Shared idea
- Both can support reasoning or decision-making.

Why is an LLM-based system not automatically an AI agent, according to this material?

An LLM-based system is not automatically an agent unless it is placed inside an autonomous perception-action architecture.

So, “having an LLM” may enable reasoning/decision support, but it becomes an agent only when embedded in an architecture that links perception to action autonomously.

When classifying an older expert system using agent taxonomies, what type is it usually, and what added capabilities could change that classification?

An older expert system with explicit if-then rules is usually a simple reflex or rule-driven system.

Its classification could change if it also maintains:
- state, and/or
- goals, and/or
- planning.

In what sense did modern LLM agents change the historical “knowledge problem” compared with expert systems?

Historically, expert systems faced the knowledge bottleneck of manually encoding every rule. Modern LLM agents shift the problem toward:

Controlling behavior generated from learned knowledge
Evaluating that behavior (rather than writing all the rules by hand)

In the historical taxonomy of AI agents, what defines a behavior-based agent, and what did Rodney Brooks’s subsumption architecture demonstrate about internal world models?

Behavior-based agent: an agent built from simple reactive behaviors that interact directly with the world, rather than relying on a complete internal representation.
Brooks’s subsumption architecture demonstrated that useful behavior can emerge from layered reactions without a complete internal world model.

Define the BDI framework by naming and explaining its three core components used to organize an agent.

Beliefs: what the agent currently thinks is true.
Desires: the goals the agent wants to achieve.
Intentions: the plans or actions to which the agent has committed.

Within the BDI perspective, how do reactive agents differ from deliberative agents, and what is common in many practical systems?

Reactive agents: respond immediately to the environment.
Deliberative agents: maintain an internal model and plan actions.
Many practical systems: are hybrid, combining reactive and deliberative elements.

What is a reinforcement learning (RL) agent in this taxonomy, and what important limitation about many historically prominent RL systems is highlighted?

RL agent: learns behavior through interaction with an environment and feedback (rewards).
Highlighted limitation: despite being powerful, many such systems were generally specialized for particular tasks and required substantial training.

If you must classify an unfamiliar historical system, which diagnostic questions (about architecture/behavior) should you ask to determine whether it is behavior-based, BDI-oriented, and/or reinforcement-learning-based?

Ask whether it reacts directly to the world (behavior-based, reactive emphasis).
Ask whether it maintains beliefs or state (internal representation/state).
Ask whether it pursues goals (goal-directed behavior; aligns with “desires” in BDI).
Ask whether it learns from interaction and feedback (reinforcement learning).

Explain the difference between how a reinforcement learning agent learns versus how an LLM learns, and state what the section says about why learning method alone does not establish “agent” status.

RL agent learning: learns from interaction and rewards.
LLM learning: learns mainly from large collections of text during pre-training.
Why learning method alone is insufficient: neither learning method alone proves that the system is an agent; the decisive factor is the system’s perception-action architecture.

How can an LLM-based agent still adapt during a task (despite LLMs learning mainly in pre-training), according to the section?

An LLM-based agent can adapt during a task by using:
- feedback
- memory
- updated instructions

Using the section’s classification cues, justify why modern LLM agents are often described as hybrid systems rather than fitting neatly into only one historical category.

The section’s cues for classification include whether a system reacts directly, maintains beliefs/state, pursues goals, and/or learns from interaction.
It concludes these distinctions help explain why modern LLM agents are often hybrid systems: they may combine multiple elements (e.g., adaptation via feedback, memory, or updated instructions) rather than matching only one historical category.

What made it practical to build general-purpose LLM-based agents (not just single-turn chat), and what kinds of work increased demand for them?

It became practical because modern LLMs can handle agent-like competencies and deployment became cheaper/easier:

Model capabilities
- Follow complex instructions
- Generate code
- Use tools
- Handle multi-step tasks
Enabling conditions
- Lower inference costs
- Mature tool-use infrastructure
- Developer frameworks
Demand drivers
- Multi-step work in software engineering, research, support, and data analysis

Classify these developments in the emergence of LLM-based agents by stating what each contributed: ReAct, Toolformer, Generative Agents, and modern systems.

ReAct
- Interleaves reasoning traces and actions, connecting deliberation to tool/world interaction.
Toolformer
- Demonstrated learning to use external tools.
Generative Agents
- Combined language models with memory to produce believable social behavior.
Modern systems
- Include coding, browsing, and multi-agent applications.

In the example of a coding agent, what is the iterative perception-action workflow that lets it make progress without building a complete model of the repository?

Perceive selectively: read selected files rather than building a complete model of the repository.
Act: make a change to the code.
Observe feedback: observe test results.
Iterate: repeat changes based on feedback.

This is agent-like because it progresses via interaction (action + observation), not one-shot generation.

Historically, how should modern LLM-based agents be described in relation to earlier agent ideas, and what core capabilities can they combine inside a perception-action loop?

They should be described as hybrid systems built on earlier ideas, combining multiple agent competencies within a perception-action loop:

React to immediate context
Maintain beliefs through context or memory
Pursue user-defined goals
Use tools
Adapt to feedback

Using the “perception-action loop” criterion, explain why an LLM-based agent is more than a language model or chatbot, and what caveat applies when assigning it a taxonomy.

An LLM-based agent is more than a language model or chatbot because its capabilities (reacting to context, maintaining beliefs via context/memory, pursuing goals, using tools, adapting to feedback) are combined inside a perception-action loop, enabling multi-step interaction with tools and the environment rather than only generating responses.
Caveat: its exact taxonomy depends on the architecture (i.e., how these components are assembled).

In the Russell & Norvig taxonomy, what is a simple reflex agent, and what are its key limitations?

A simple reflex agent selects an action using only the current percept.

How it works: behavior is typically represented by condition–action rules (e.g., “if temperature > 25°C, turn on cooling”).
What it lacks:
- No memory
- No internal world model
- No planning
Key limitations:
- Fails when the current percept is incomplete (partial observability).
- Fails when the correct action depends on history or on consequences over time.

In the Russell & Norvig taxonomy, what is a model-based reflex agent, and what capability does its internal state add beyond simple reflex behavior?

A model-based reflex agent maintains an internal state representing relevant aspects of the world and updates that state after receiving new percepts.

Core added capability: it can reason about things that are not currently visible by combining:
- the current percept, and
- what it remembers (its internal state / history).
Illustrative mechanism: if motion was detected recently, the agent can retain the belief that a room is probably occupied even when the sensor currently detects no movement.

You are classifying an agent as simple reflex vs model-based reflex. What single diagnostic question best distinguishes them, and what is the main difference?

The key diagnostic is whether the system uses only the current observation or also an internal state.

Simple reflex diagnostic: “What is the current percept?” (action depends only on the latest percept).
Model-based diagnostic: “Given the current percept and what I remember, what is probably happening?”
Main difference: use of history and internal state (memory of relevant past percepts to infer the current situation).

Classify each system as simple reflex or model-based reflex, and justify briefly: (1) a thermostat that applies a fixed response to the current temperature; (2) smart lighting that combines a current sensor reading with remembered motion and elapsed time to infer occupancy.

(1) Thermostat: simple reflex
- It applies a fixed response to the current temperature (current percept only), with no internal state used to infer hidden conditions.
(2) Smart lighting: model-based reflex
- It combines the current sensor reading with remembered motion and elapsed time, i.e., an internal state, to infer an unobserved situation (whether the room is occupied).

In the Russell & Norvig taxonomy, what is a goal-based agent, and what makes its action selection different from simply reacting to the current percept?

A goal-based agent selects actions by considering a desired future state and choosing actions that help reach it. Its action selection is driven by whether actions move the world from the current state toward a goal state, rather than merely mapping the current percept directly to an action.

This requires thinking ahead: the agent evaluates future states that could result from different action sequences.
So, it acts to change the world toward a goal, not just respond to what it perceives right now.

What core elements must a system have to function as a goal-based agent (Russell & Norvig taxonomy), and what role does each element play?

A goal-based agent needs:

Current state
- Represents where the agent is now.
Goal state
- Represents what successful completion looks like (the desired future state).
World model
- Represents how actions change the state of the world.
Search or planning
- Finds a useful sequence of actions that can take the agent from the current state to the goal state.

Describe the typical operating cycle of a goal-based agent, including how it handles new information during execution.

A typical goal-based agent operates as:

Represent state and goal
- Maintain a current state and a goal state.
Plan/search
- Use a world model plus search or planning to find a useful action sequence.
Execute with feedback
- Act, observe outcomes, and use feedback to update the current state.
Replan if necessary
- If conditions change (e.g., an action is no longer feasible), search for an alternative plan that still reaches the goal.

Why is a navigation application an example of a goal-based agent? Identify the goal, model, and planning behavior it uses.

A navigation application is goal-based because it explicitly represents:

Goal state
- The destination (desired future state).
Current state
- The agent’s current location.
World model
- The road network (how routes connect and enable movement from one state/location to another).
Search/planning
- It searches for a route (a sequence of road segments/actions) expected to reach the destination.

A road becomes blocked while a navigation system is guiding a driver. Explain how this situation demonstrates goal-based behavior rather than a simple reflex response.

A road closure demonstrates goal-based behavior because the system:

Maintains the same goal state
- It still aims to reach the destination despite the blockage.
Uses a model to anticipate consequences
- It relies on the road network model to understand alternative ways actions can change the state.
Replans via search
- It searches for an alternative route, showing planning toward a future goal rather than merely responding to the immediate percept.

What is the key reason a simple reflex agent cannot be classified as a goal-based agent in this summary?

A simple reflex agent cannot be goal-based because it lacks:

A representation of a future goal
- It does not encode a desired future (goal) state.
A plan (or planning/search) that connects current state to the goal
- Without planning, it cannot choose actions based on whether they help reach a future state.

So it cannot do tasks like rerouting to still reach a destination when conditions change.

In Russell & Norvig’s taxonomy, what is a utility-based agent, and what role does a utility function play in its action selection?

A utility-based agent uses a utility function to evaluate how desirable different possible outcome states are, then chooses actions that lead to the most desirable outcome.

A utility function assigns a numerical value to a state to represent how desirable that state is.
The agent uses these values to choose between different actions or outcomes that may all achieve the basic goal, but differ in quality (e.g., faster, cheaper, safer, more comfortable).

A navigation system can find multiple routes that all reach the airport. What criterion distinguishes a goal-based agent from a utility-based agent in this situation?

The key distinction is whether the system only seeks a successful goal state or also compares the quality of alternative successful states.

Goal-based agent: aims to reach a goal state (success/failure framing) without needing to rank different successful outcomes.
Utility-based agent: evaluates and compares multiple goal-reaching routes using a utility function (e.g., by time, cost, safety, comfort) and selects the most desirable among them.

For a utility-based agent, explain the meaning of the decision rule a^∗ = arg max_a∈A U(result(s,a)) by defining each symbol and stating what the rule selects.

The rule selects the action whose expected resulting state has the highest utility.

a^∗: the selected action.
A: the set of available actions.
s: the current state.
result(s,a): the state expected after taking action a in state s.
U(…): the utility function that assigns a numerical desirability value to a state.
arg max: “choose the action a that maximizes the expression.”

A travel planner assigns high utility to short travel time, low cost, and few transfers. How does this illustrate what utility adds beyond merely “reaching the destination”?

It shows that utility supports trade-offs among multiple preferences when several options all satisfy the basic goal of reaching the destination.

The goal specifies what counts as success (arrive at the destination).
The utility function ranks different successful routes by desirability (e.g., short time, low cost, few transfers), enabling the agent to choose the route that best balances those preferences rather than picking the first route that works.

What is a learning agent, and what parts of an agent can learning change?

A learning agent is an agent that improves its behavior from experience, feedback, or new information. Learning can modify multiple aspects of the agent, including:

Rules
- How it chooses actions based on conditions.
Internal model
- Its maintained representation of the environment.
Action policy
- The mapping from perceived situations to actions.
Evaluation of outcomes
- How it judges results and uses that to improve future behavior.

Why is “learning” treated as an additional capability rather than a replacement for other Russell & Norvig-style agent categories?

Learning is an additional capability because a single system can be a learning agent and simultaneously fit other categories based on how it operates. For example, a system can:

Maintain an internal model (model-based)
Pursue a goal (goal-based)
Compare options using criteria (utility-based)
Change behavior based on errors/feedback (learning or adaptive)

So “learning” does not displace being model-based, goal-based, or utility-based; it can coexist with them.

A coding assistant works on a repository and runs tests. Classify it as model-based, goal-based, utility-based, and/or learning/adaptive given these behaviors: it maintains a representation of the repository, tries to implement a requested feature or fix, compares solutions by correctness/simplicity/risk, and changes behavior after test failures. Explain the justification for each label.

This coding assistant is a hybrid and can validly be all four:

Model-based
- It maintains an internal representation of the repository.
Goal-based
- It tries to implement a requested feature or fix.
Utility-based
- It compares solutions using criteria such as correctness, simplicity, or risk.
Learning/adaptive
- It changes its behavior based on errors or feedback (e.g., test failures during the task).

What does it mean that the taxonomy is “best understood as a ladder of increasing sophistication,” and how should that affect classification of modern LLM-based agents?

“Ladder of increasing sophistication” means the categories can be viewed as adding capabilities in a way that often becomes more sophisticated as you move upward. However, real systems—especially modern LLM-based agents—are often hybrid rather than pure instances of just one category. Therefore, classification should allow multiple labels when the system exhibits multiple capabilities, rather than forcing a single exclusive category.

When classifying a modern agent, what is the recommended approach instead of forcing one exclusive label, and what makes the classification “more accurate”?

Do not force a modern agent into one exclusive label. Instead:

Assign multiple labels (e.g., model-based, goal-based, utility-based, learning) when the agent’s behavior supports them.
Make the classification “more accurate” by stating which behavior supports each label (e.g., internal model → model-based; test feedback adaptation → learning/adaptive).

This is more informative than calling it merely an “LLM agent.”

In the coding-assistant example, what does it mean to say the system is agentic overall?

Saying it is agentic overall means it operates as an agent that repeatedly:

Perceives
Reasons
Acts
Adapts

This repeated perception–reasoning–action–adaptation cycle supports describing the system as agentic, beyond any single category label.

What are the six environment-property dimensions (Russell & Norvig) used to classify an AI agent’s environment, and what does each dimension mean?

Fully observable vs partially observable
- Whether the agent can access the complete relevant state.
Deterministic vs stochastic
- Whether the same action reliably produces the same result.
Episodic vs sequential
- Whether each decision is independent or affects later decisions.
Static vs dynamic
- Whether the environment changes while the agent is deciding.
Discrete vs continuous
- Whether states and actions are separate options or vary continuously.
Single-agent vs multi-agent
- Whether other agents or people also act in the environment.

Classify a “coding agent working in a repository” along the environment-property dimensions supported by the material, and give the reason for each classification.

Partially observable
- The agent cannot inspect the entire codebase at once.
Stochastic
- LLM outputs and software behavior can vary, so the same action may not yield the same result.
Sequential
- One edit affects later states (later decisions depend on earlier edits).
Dynamic
- Other developers may change files while the agent is deciding.
Multi-agent
- Humans, CI systems, or other assistants also act on the repository.

In an exam classification scenario, how should environment properties be used to justify what agent capabilities are needed (according to the material)?

Use environment properties to explain required capabilities
- The point of classifying the environment is to justify why certain agent capabilities are needed for effective behavior in that environment.
Example pattern from the material
- In a partially observable and sequential repository, an agent cannot rely only on current input; it must remember relevant files and anticipate effects of earlier edits.

Why does a coding agent in a partially observable and sequential repository environment fit better as “model-based, goal-based, and adaptive” rather than “simple reflex,” based on the given reasoning?

Partially observable
- The agent lacks complete access to the full relevant state at once, so it cannot act purely from immediate input; it needs internal state (a model) to track what matters.
Sequential
- Because edits affect later states, the agent must anticipate consequences of earlier actions and plan toward outcomes, supporting a goal-based framing.
Adaptive implication
- The environmental structure supports an adaptive classification rather than a simple reflex classification.

Classify each system by agent taxonomy (if any): pocket calculator; keyword spam filter with fixed condition→action rules; thermostat; smart lighting that keeps an internal state of recent sensor readings; navigation app that chooses a route to a destination and may rank routes by user preferences; reinforcement learning game player that improves from experience.

Pocket calculator: traditional deterministic program; not meaningfully autonomous (so not an agent in this taxonomy).
Keyword spam filter (fixed rules): simple reflex classifier with fixed condition-action rules.
Thermostat: simple reflex agent.
Smart lighting with internal state: model-based reflex agent (it uses stored state beyond the immediate percept).
Navigation app: goal-based agent (reaches a destination); utility-based if it ranks routes by preferences.
Reinforcement learning game player: learning agent, often with a task-specific policy.

A “one-turn chatbot” uses an LLM to generate a single response in a conversation. Under what condition(s) is it not necessarily an agent, and what extra capability would distinguish an agentic system from it?

Not necessarily an agent: a one-turn chatbot can be only an LLM-backed conversational tool that produces a reply without meaningful autonomy.
What distinguishes an agentic system: an agent interacts with external systems and changes the environment (i.e., it perceives, reasons over steps, takes actions, and observes consequences), rather than only returning a text response.

An email system: reads incoming messages, remembers previous conversations, decides which messages need replies, checks the user’s calendar, drafts responses, asks approval for sensitive messages, and sends approved replies. Explain why it counts as an AI agent (not merely a chatbot) using the properties given.

Why it is an agent: it perceives email and calendar information, reasons over several steps, takes actions (drafts/asks/sends), and operates with partial autonomy.
Why it is not merely a chatbot: it interacts with external systems (email + calendar) and changes the environment (e.g., sending replies), rather than only producing conversation text.

For the same email system (reads email, tracks conversation, uses calendar, drafts replies, requests approval for sensitive messages, sends approved replies), give a complete classification across the relevant taxonomy categories and the specific evidence for each category.

Agentic: it repeatedly perceives messages/calendar state, selects actions, and observes consequences.
Model-based: it maintains state (stored conversation and calendar state).
Goal-based: it pursues task objectives such as resolving messages or scheduling meetings.
Utility-based (conditional): if it ranks possible meeting times by preferences.
Learning-based (conditional): if it improves from feedback.

When you must provide a “complete classification” of a real system as an AI agent, what kind of justification should you combine, and how does that help distinguish an agentic email assistant from a fixed email classifier?

What to combine: architectural evidence (what the system perceives, stores, decides, and does repeatedly) with the taxonomy (model-based/goal-based/utility-based/learning-based, as applicable).
How it distinguishes systems: an agentic email assistant repeatedly perceives state, selects actions, and observes consequences, and may be model-based/goal-based/utility-based/learning-based; a fixed email classifier is limited to fixed classification rules rather than multi-step action selection that changes the environment.

An “autonomous coding assistant” is described as a hybrid agent type. What taxonomy categories can it combine, according to the comparison, and what does “hybrid” mean here?

Categories it can combine: model-based, goal-based, utility-based, and learning agent.
Meaning of “hybrid” here: one system can exhibit evidence for multiple agent categories simultaneously (e.g., keeps state, pursues goals, ranks options by preferences, and improves from feedback).

In agent classification, what does the expression f: Percept^∗ → Action mean, and when is the “^∗” especially useful in your justification?

The expression f: Percept^∗ → Action means an agent’s action can depend on the entire history of observations (not just the current percept). The “^∗” is especially useful when justifying a model-based classification, because dependence on percept history supports the claim that the agent maintains some form of internal state/memory rather than responding only to the immediate input.

What explicit comparison should you include when defining and classifying an unfamiliar system as an agent, and why must you support labels with evidence?

Explicit comparison to include: compare the system explicitly with a traditional program or a one-turn chatbot.
Why evidence is required: each label must be justified with a concrete behavior from the scenario; you should not award a category simply because the system is complex.

If an exam scenario describes a system that produces outputs, which specific properties must you check to argue it is an autonomous AI agent rather than a fixed-response system?

Perception and action: identify what it perceives and what actions it can take (to establish a perception–action loop).
Autonomy vs fixed response: explain whether it acts autonomously or follows a fixed response.
Internal state/memory: check whether it maintains internal state or memory (potentially implied by dependence on percept history).
Learning/adaptation: check whether it learns or adapts from feedback, which supports autonomy beyond fixed rules.

In the provided agent-classification answer structure, which elements specifically test for “decision-making” (choosing among alternatives), and how should you use them in your classification?

Goals and planning: identify the system’s goals and, if relevant, how it plans (evidence that actions are selected to achieve objectives).
Preferences/utility: check whether it compares alternatives using preferences or utility (evidence of evaluating choices rather than emitting a single fixed response).
Use in classification: for any decision-making label you apply, justify it with a concrete behavior from the scenario rather than complexity alone.

In an exam classification of an AI agent, what elements must you define first before applying any taxonomy labels, and why is this ordering important?

Define first:
- Environment (what the system is situated in)
- Percepts (what it observes from the environment)
- Actions (what it can do to affect the environment)
- Goal (what counts as success)
Why this ordering matters: starting with an unsupported label (e.g., “this is an intelligent agent”) is weak; defining environment/percepts/actions/goal provides the behavioral evidence needed to justify later classification claims.

What is the shortest correct mental model of an AI agent’s operation, expressed as a complete cycle?

Observe the environment.
Use current information and possibly history.
Decide what action to take.
Act toward a goal.
Observe the result.
Adapt or continue (repeat the cycle).

When asked to “describe at least one complete perception-action cycle,” what must your description include to be considered complete?

A complete description includes:
- Perception: what the system observes (its percepts) from the environment.
- Decision: how it uses current information and possibly history to choose an action.
- Action: what it does in the environment toward a goal.
- Feedback: what it observes after acting (the result) and whether it will adapt or continue.

In classifying whether a system is an AI agent, what does it mean to explain the system’s autonomy?

Autonomy means the system autonomously repeats the observe–decide–act cycle rather than producing a single one-off response.
Evidence for autonomy includes that it:
- continues to observe the environment,
- acts without being manually re-invoked for each step,
- and can adapt or continue based on results.

What is the required distinction between current percepts and remembered internal state when analyzing an AI system as an agent?

Current percepts: information the system is receiving/observing now from the environment.
Remembered internal state: information it retains from history (memory) and uses alongside current percepts.
For an agent analysis, you should explicitly separate what comes from the environment right now from what is stored and carried over as internal state.

In agent analysis, how do you separate goals from utilities, and what does each one mean?

Goal: states what counts as success (a success criterion).
Utility: states which successful outcome is preferred (a preference ranking among successes).
So, two outcomes can both satisfy the goal, but utility indicates which of those successes is better.

Why is an LLM, chatbot, classifier, or traditional program not automatically an agent, and what added properties make something “much more clearly” an AI agent?

Such systems are not automatically agents because they may only map one input to one output and still be useful AI.
A system is “much more clearly” an AI agent if it:
- autonomously repeats the perception–action cycle,
- maintains relevant state (uses history/internal state),
- and acts toward goals in an environment.

What is the recommended way to justify an AI-agent taxonomy classification in an exam answer when multiple categories might apply?

Mention multiple taxonomy categories when the evidence supports them, rather than forcing a single label.
Justify claims with behavior: base the classification on what the system observes, how it uses information/history, what actions it takes, and how it pursues goals.
Do not justify by product names; historical examples (e.g., MYCIN, Brooks’s robots, AlphaGo, ReAct) should only strengthen a behavior-based classification.

An exam scenario describes an LLM-based email assistant that monitors an inbox over time, remembers threads, drafts replies, checks a calendar, asks for approval on sensitive messages, and sends approved replies. How would you integrate the definition of an agent, the perception-action loop, and the Russell & Norvig taxonomy to justify that it is an AI agent (not a one-turn chatbot)?

It qualifies as an AI agent because it runs an ongoing perception-action loop: it perceives emails/calendar state, decides what to do next, acts by drafting/scheduling/sending, then observes consequences (new messages, updated calendar) and repeats. In Russell & Norvig terms it is model-based (stores conversation/calendar state), goal-based (aims to resolve messages/schedule meetings), and can be utility-based if it ranks options (e.g., meeting times by preferences). Approval requests are compatible with agency because full autonomy is not required; the architecture and behavior, not “uses GPT,” establish agency.

How do environment properties and the agent taxonomy combine to justify why a coding agent in a repository should be classified as model-based, goal-based, and adaptive rather than simple reflex?

A repository environment is typically partially observable (the agent cannot inspect everything at once) and sequential (each edit changes what becomes possible/necessary later). Those two properties make “current percept only” behavior unreliable, so the agent benefits from internal state (model-based) to retain relevant file/test information across steps. Because progress requires selecting sequences of edits/tests toward a target (e.g., implementing a feature or passing tests), it is naturally goal-based rather than simple reflex. Iterating on failures uses feedback (test results as new percepts), supporting an adaptive/learning label during the task.

Define and classify AI agents according to established taxonomies, distinguishing them from traditional AI systems and chatbots

86 important questions on Define and classify AI agents according to established taxonomies, distinguishing them from traditional AI systems and chatbots