Wrap-Up and Self-Assessment

Unit 2: Intelligent Agents — Wrap-Up

Every AI system is an agent. This week you acquired a universal framework for analyzing any AI system you encounter — not just the ones built in this course, but any AI system you will read about, use, or design throughout your career. The agent framework (PEAS + environment taxonomy + architecture selection) is one of the most durable tools in AI.

Key Takeaways

Agents and Environments (Section 2.1)

An agent perceives its environment through sensors and acts upon it through actuators
The percept sequence is the complete history of all inputs the agent has received
The agent function maps percept sequences to actions — the ideal; the agent program is the executable implementation
A rational agent selects actions expected to maximize its performance given available information

PEAS Framework (Section 2.2)

Performance: How success is evaluated — set by the designer, not the agent
Environment: The world the agent operates in
Actuators: Mechanisms through which the agent acts
Sensors: Mechanisms through which the agent perceives
Performance measures often involve competing criteria — the designer must specify trade-offs explicitly

Environment Properties (Section 2.3)

The six dimensions and their design implications:

Dimension	Easy Side	Hard Side	Design Challenge (Hard Side)
Observable	Fully observable	Partially observable	Agent must maintain internal beliefs about hidden state
Deterministic	Deterministic	Stochastic	Agent must reason about probabilities and handle surprises
Episodic	Episodic	Sequential	Agent must plan and consider future consequences
Static	Static	Dynamic	Agent must decide quickly — the world won’t wait
Discrete	Discrete	Continuous	Agent must use approximation over infinite state spaces
Agents	Single-agent	Multi-agent	Agent must model other agents' goals and strategies

Dimension

Easy Side

Hard Side

Design Challenge (Hard Side)

Observable

Fully observable

Partially observable

Agent must maintain internal beliefs about hidden state

Deterministic

Stochastic

Agent must reason about probabilities and handle surprises

Episodic

Sequential

Agent must plan and consider future consequences

Static

Dynamic

Agent must decide quickly — the world won’t wait

Discrete

Continuous

Agent must use approximation over infinite state spaces

Agents

Single-agent

Multi-agent

Agent must model other agents' goals and strategies

Agent Architectures (Section 2.4)

Architecture	Core Idea	Best Suited For
Simple Reflex	IF condition THEN action — reacts to current percept only	Fully observable, simple, reactive tasks
Model-Based Reflex	Maintains internal state about hidden parts of the world	Partially observable, reactive tasks
Goal-Based	Represents goals; uses search or planning to achieve them	Sequential environments requiring planning
Utility-Based	Maximizes a utility function; handles trade-offs and uncertainty	Multiple competing objectives; stochastic environments

Architecture

Core Idea

Best Suited For

Simple Reflex

IF condition THEN action — reacts to current percept only

Fully observable, simple, reactive tasks

Model-Based Reflex

Maintains internal state about hidden parts of the world

Partially observable, reactive tasks

Goal-Based

Represents goals; uses search or planning to achieve them

Sequential environments requiring planning

Utility-Based

Maximizes a utility function; handles trade-offs and uncertainty

Multiple competing objectives; stochastic environments

Learning Agents (Section 2.5)

Performance Element: Selects actions (the current agent)
Critic: Evaluates performance against a fixed standard; provides feedback
Learning Element: Updates the performance element to improve future behavior
Problem Generator: Suggests exploratory actions to expand the agent’s experience
Three learning modes: supervised (labeled examples), unsupervised (find patterns), reinforcement (rewards for outcomes)

The Connecting Logic

Everything in Unit 2 forms a coherent design process:

Designing an Intelligent Agent — End to End:

Specify with PEAS — clarify performance criteria, environment scope, available actuators, and sensor capabilities
Classify the environment — work through all six dimensions to understand the agent’s design challenges
Select an architecture — choose the minimum architecture sufficient for the environment’s properties
Add learning — if the environment changes or cannot be fully specified in advance, add a learning layer

Applying the Full Process to a Self-Driving Taxi:

PEAS: Performance = safe arrival + efficiency + comfort; Environment = roads, traffic, weather; Actuators = steering, brake, accelerator; Sensors = cameras, LIDAR, GPS
Environment classification: Partially observable (hidden vehicles), stochastic (unpredictable drivers), sequential (route choices matter), dynamic (world moves while deciding), continuous (smooth position/velocity), multi-agent (other vehicles and pedestrians)
Architecture: Utility-based — must balance safety, speed, fuel, and comfort simultaneously; must reason about uncertain outcomes
Learning: Add learning element to improve performance from thousands of driving hours; problem generator tests edge cases (rain, night, unusual intersections)

Self-Assessment Checklist

Before moving to Unit 3, make sure you can do each of the following:

Define agent, percept, percept sequence, agent function, and agent program in your own words
Write a complete PEAS description for any given AI system
Classify an environment along all six dimensions with justification
Explain why each "hard" property creates a specific design challenge
Describe each of the four architectures and state when each is most appropriate
Name the four components of a learning agent and explain what each one does
Distinguish supervised, unsupervised, and reinforcement learning by the type of feedback provided

Unit Self-Check Quiz

Test your understanding of all Unit 2 concepts.

Unit 2 Glossary

Agent: An entity that perceives its environment through sensors and acts upon it through actuators.
Actuator: A mechanism through which an agent executes actions in its environment (e.g., motors, display screens, network connections).
Agent Function: The mathematical mapping from percept sequences to actions — the theoretical ideal of what the agent should do.
Agent Program: The concrete, executable implementation that approximates the agent function on real hardware.
Critic: The component of a learning agent that evaluates performance and provides feedback to the learning element.
Episodic Environment: An environment in which each agent–environment interaction episode is independent of future episodes.
Goal-Based Agent: An agent that explicitly represents goals and uses search or planning to find action sequences that achieve them.
Learning Element: The component of a learning agent that updates the performance element based on the critic’s feedback.
Model-Based Reflex Agent: An agent that maintains internal state to track parts of the world not currently visible through sensors.
PEAS: A framework for specifying agent design: Performance measure, Environment, Actuators, Sensors.
Percept: A single perceptual input the agent receives from its sensors at one moment in time.
Percept Sequence: The complete history of all percepts an agent has ever received.
Performance Element: The component of a learning agent that selects actions — the "current agent" being improved by learning.
Problem Generator: The component of a learning agent that suggests exploratory actions to expand the agent’s experience.
Rational Agent: An agent that selects actions expected to maximize its performance measure given its percept history and built-in knowledge.
Sensor: A mechanism through which an agent receives percepts from its environment.
Simple Reflex Agent: An agent that selects actions based solely on the current percept using condition-action rules (IF–THEN rules).
Stochastic Environment: An environment that contains randomness — the same action in the same state can produce different outcomes.
Utility-Based Agent: An agent that maximizes a utility function, allowing it to balance competing objectives and reason under uncertainty.

Connection to Unit 3

Looking Ahead: Unit 3 — Search Techniques for Problem Solving

In Unit 2 you learned that goal-based agents plan ahead by searching for action sequences that achieve their goals. In Unit 3 you will learn how that search actually works.

Specifically, you will learn:

How to formulate real-world problems as search problems (states, actions, transition model, goal test, path cost)
How uninformed search algorithms (BFS, DFS, uniform-cost search) explore a state space without domain knowledge
How informed search algorithms (A*, greedy best-first) use heuristics to search more efficiently
How to design effective heuristics that guide search toward the goal

Everything in Unit 3 is built on the agent framework you learned this week. A search algorithm is the implementation of a goal-based agent’s planning component.

Proceed to Unit 3: Search Techniques →

Based on the UC Berkeley CS 188 Online Textbook by Nikhil Sharma, Josh Hug, Jacky Liang, and Henry Zhu, licensed under CC BY-SA 4.0.

This work is licensed under CC BY-SA 4.0.