Simple Reflex Agent Decisions Based on Current Input
The calculator for this page is switched off while it is checked. The formula is below, and the worked example in the article shows how to use it by hand.
A simple reflex agent chooses an action using only the current percept—the immediate sensor input—with no memory of past states and no internal model of the world. You provide the agent with a rule table (condition-action rules) and the current input; it matches the input to a rule and executes the corresponding action. This article explains how these agents work, their strengths and limits, and how to design the rule set for a given task.
Formula
The decision is a simple threshold test: if (distance / (reaction time × speed factor)) < safety margin, then brake; else continue. In the calculator above, the speed factor is assumed to be 10 m/s (about 36 km/h) and the safety margin is 1.0 second. The expression (d / (t * 10) < 1) evaluates to 1 (brake) when the time to reach the obstacle is less than 1 second, otherwise 0 (continue).
Worked Example
Using the defaults: reaction time = 0.5 s, distance = 2 m.
- Compute the speed factor: 10 m/s.
- Compute time to obstacle: distance / speed = 2 / 10 = 0.2 s.
- Compare with reaction time: 0.2 s < 0.5 s → the agent does not have enough time to react, so it brakes.
The result is 1 (brake), matching the calculator output.
What Is a Simple Reflex Agent?
A simple reflex agent is the most basic type of intelligent agent in artificial intelligence. It operates on a percept-action cycle: sense the world, look up a rule, act. The rules are usually written as if-then statements, such as “if the temperature is below 0°C, turn on the heater.” The agent has no memory of previous percepts—each decision is independent and based solely on the current sensor reading.
This architecture was formalized in Stuart Russell and Peter Norvig’s textbook Artificial Intelligence: A Modern Approach, where it is contrasted with model-based agents, goal-based agents, and utility-based agents. Simple reflex agents are also called stimulus-response agents because they react directly to stimuli.
How Simple Reflex Agents Work
The core mechanism is a lookup table or a set of condition-action rules. The agent receives a percept (e.g., a camera image, a sensor value, a user command), maps it to a condition, and triggers the associated action. The mapping is predefined by a designer or learned offline—the agent does not learn online.
Key characteristics:
- No memory: The agent does not store previous percepts or actions.
- No state: It does not maintain an internal representation of the world.
- Deterministic: For a given input, the same action is always chosen (unless the rules include randomness).
- Fast: Because there is no search or planning, the response time is very low.
In practice, the percept is often processed by a perception function that extracts relevant features (e.g., “distance to obstacle”), and then the rule engine applies the rules.
When to Use a Simple Reflex Agent
Simple reflex agents are appropriate when the environment is fully observable and the correct action depends only on the current state. That means the sensor provides all the information needed to choose the best action, and the world does not change in ways that require memory of past events.
Common applications:
- Thermostats: if temperature < setpoint, turn on heating.
- Automatic doors: if motion detected, open.
- Spam filters: if email contains certain keywords, mark as spam.
- Robotic vacuum cleaners: if bump sensor triggered, reverse.
- Traffic light controllers: if vehicle detected on side road, change light.
They are also used as components in more complex agents—for example, a reflex layer that handles emergency responses while a planning layer handles long-term goals.
Limitations and Common Pitfalls
The biggest limitation is that simple reflex agents fail in partial observable environments where the current percept is ambiguous. For instance, a robot with a single camera cannot tell if the object in front is a wall or a person—both produce the same pixel pattern. Without memory, it cannot disambiguate.
Another issue is that the rule set can become enormous. If the percept has many dimensions (e.g., 10 sensors each with 10 possible values), the number of possible percepts is 10^10, making a complete lookup table impractical. Designers must generalize rules, but that can lead to incorrect decisions for unanticipated inputs.
Common pitfalls when designing a simple reflex agent:
- Ignoring sensor noise: Real sensors have noise; a rule based on a precise threshold may cause erratic behavior. Use hysteresis or filtering.
- Missing rules: If no rule matches the current percept, the agent may do nothing or crash. Always include a default rule.
- Overfitting: Too many specific rules may work for the training scenarios but fail in new situations.
- Assuming full observability: In many real-world tasks, the current sensor reading is not enough to choose the best action.
Comparison with Other Agent Types
Simple reflex agents are often compared with:
- Model-based agents: They maintain an internal state that tracks unobserved parts of the world. For example, a robot that remembers where it has been can avoid revisiting locations.
- Goal-based agents: They consider future actions to achieve a goal, using search or planning. A navigation agent plans a path, not just reacts.
- Utility-based agents: They choose actions that maximize a utility function, allowing trade-offs between conflicting goals.
- Learning agents: They improve their rules over time based on feedback.
The key trade-off is simplicity vs. flexibility. Simple reflex agents are easy to implement and debug, but they cannot handle tasks that require memory or reasoning. For example, a chess-playing agent cannot be a simple reflex agent because the best move depends on the entire board history, not just the current position.
Designing a Rule Set
To create a simple reflex agent, follow these steps:
- Define the percept space: what sensors are available and what values can they produce?
- Define the action space: what actions can the agent perform?
- Enumerate the conditions: for each percept or group of percepts, decide the appropriate action.
- Write the rules in the form if condition then action.
- Test with representative inputs, including edge cases.
For example, a simple agent that decides whether to take an umbrella could have rules:
- if weather = rainy → take umbrella
- if weather = cloudy → take umbrella (to be safe)
- if weather = sunny → do not take umbrella
In practice, you might use a decision tree or a lookup table. The rules can be hand-coded or generated by a learning algorithm from labeled examples.
Frequently Asked Questions
Can a simple reflex agent learn?
No, a pure simple reflex agent cannot learn. Its rules are fixed at design time. However, you can add a learning component that updates the rules based on feedback, but then it is no longer a simple reflex agent—it becomes a learning agent.
What is the difference between a simple reflex agent and a model-based agent?
A simple reflex agent uses only the current percept to decide; a model-based agent maintains an internal state that represents unobserved aspects of the world. For example, a model-based agent might remember that the door was open a moment ago, even if the current sensor says closed.
Do simple reflex agents have memory?
No, they do not store any past percepts or actions. Each decision is based solely on the current input. This is what makes them “simple.”
What are some real-world examples of simple reflex agents?
Thermostats, automatic doors, and basic spam filters are classic examples. Also, many embedded systems like washing machines use simple reflex logic based on sensor readings (e.g., water level, temperature).
Can a simple reflex agent work in a dynamic environment?
Yes, as long as the environment is fully observable. If the current sensor reading gives all necessary information, the agent can react correctly even if the world changes. However, if the environment has hidden states, a simple reflex agent will fail.
How do you handle sensor noise in a simple reflex agent?
You can smooth the sensor readings using a moving average or a low-pass filter, or you can add hysteresis (e.g., turn on the heater at 20°C but turn it off at 22°C) to prevent rapid switching.