AI Agents — Types and Architecture
An AI agent is any entity that perceives its environment through sensors and acts upon that environment through actuators to maximize its performance measure. Russell & Norvig define five progressively powerful agent architectures — simple reflex, model-based reflex, goal-based, utility-based, and learning — each suited to different environment types. The PEAS framework (Performance, Environment, Actuators, Sensors) is the standard tool for specifying any agent design. Core GATE DS&AI topic.
The five fundamental agent designs: from simple reflex to fully learning systems.
Category: AI Fundamentals
Real-life analogy: Five levels of driving autonomy
The five agent types map to self-driving car levels: Simple reflex = emergency brake (if obstacle, stop — no memory). Model-based reflex = lane-assist (maintains an internal model of the road). Goal-based = GPS navigation (plans a route to a destination). Utility-based = full self-driving (balances speed, safety, fuel — no single goal). Learning agent = Tesla FSD (improves from millions of real-world trips).
| Agent type | Driving analogy | Classic AI example |
|---|---|---|
| Simple reflex | Emergency brake sensor | Thermostat, keyword spam filter |
| Model-based reflex | Lane-assist with road model | Robot vacuum with floor map |
| Goal-based | GPS navigation | A* path planner, chess opening book |
| Utility-based | Full self-driving (trade-offs) | Atari DQN, trading bots |
| Learning agent | Tesla FSD learning fleet | GPT, AlphaGo, recommendation engines |
PEAS framework — defining any agent task
PEAS (Performance measure, Environment, Actuators, Sensors) is the standard specification framework for AI agents. Every GATE question about agent design can be answered systematically using PEAS.
| PEAS | Taxi driver agent | Email spam filter | Chess AI |
|---|---|---|---|
| Performance | Safe trips, profit, comfort | Spam blocked, no false positives | Win games |
| Environment | Roads, traffic, weather | Inbox: text, headers, senders | Chess board (8x8) |
| Actuators | Steering, brakes, accelerator | Block / allow / folder-route | Choose and play a move |
| Sensors | Camera, GPS, speedometer | Email content, sender reputation | Board state (fully observable) |
Environment types — the GATE taxonomy
| Property | Easier | Harder | Example |
|---|---|---|---|
| Observability | Fully observable | Partially observable | Chess (full) vs Poker (partial) |
| Determinism | Deterministic | Stochastic | Rubik's cube vs weather forecasting |
| Episodicity | Episodic | Sequential | Image classifier vs chess |
| Dynamism | Static | Dynamic | Crossword vs taxi driving |
| Discreteness | Discrete | Continuous | Chess vs robot arm control |
| Agent count | Single-agent | Multi-agent | Maze solver vs RTS game |
GATE answer: hardest real-world environment: The hardest AI environment is: partially observable + stochastic + sequential + dynamic + continuous + multi-agent. Real autonomous driving fits this description. The easiest (fully observable, deterministic, episodic, static, discrete, single-agent) describes simple puzzles like Sudoku.
Inside each architecture — what the agent program contains
| Agent type | Internal machinery | Decision rule | Fails when |
|---|---|---|---|
| Simple reflex | Condition–action rules only | if percept matches condition → act | Environment is partially observable (no memory of what it can't currently see) |
| Model-based reflex | Rules + internal state + transition model ("how the world evolves") + sensor model | Update state from percept history, then match rules | Reaching the objective requires looking ahead, not just reacting |
| Goal-based | State + model + explicit goal description + search/planning | Choose actions whose predicted outcome reaches the goal | Goals conflict or come in degrees — binary achieved/not-achieved is too crude |
| Utility-based | State + model + utility function U(state) | Choose the action maximizing expected utility | The utility function is wrong or unmeasurable (see reward hacking in RL) |
| Learning | Any of the above + learning element, critic, and problem generator | Improve the performance element from experience | — (this is a wrapper that upgrades any other architecture) |
The learning agent has four named components that GATE asks about by name: the performance element (the acting agent — any of the four architectures above), the critic (evaluates behavior against a fixed performance standard and produces feedback), the learning element (uses that feedback to improve the performance element), and the problem generator (proposes exploratory actions the agent wouldn't otherwise take — deliberately suboptimal in the short run to gather informative experience). The critic's standard must sit outside the agent, or it could "improve" by simply redefining success.
Rationality, omniscience, and autonomy
A rational agent selects the action expected to maximize its performance measure, given the percept sequence so far and its built-in knowledge. Rationality is not omniscience: an agent that crosses a street after checking both ways is rational even if a falling piano flattens it — rationality maximizes expected outcome, not actual outcome. Nor does rationality require success on day one: an agent lacking autonomy relies wholly on its designer's prior knowledge, while an autonomous agent compensates for incomplete or wrong priors by learning from its own percepts.
The exam formulation: Rationality at any moment depends on exactly four things: (1) the performance measure defining success, (2) the agent's prior knowledge of the environment, (3) the actions available to it, and (4) the percept sequence to date. Any question asking "is this agent rational?" is answered by checking these four — nothing else.
From textbook agents to LLM agents
The Russell & Norvig taxonomy predates ChatGPT by decades, but it maps cleanly onto today's LLM-based agents — and using its vocabulary precisely is a genuine differentiator in interviews:
| Classical concept | LLM-agent equivalent |
|---|---|
| Percepts / sensors | Tool outputs, retrieved documents, API responses, user messages |
| Actuators | Tool calls: code execution, web search, file writes, API requests |
| Internal state (model-based) | The context window + external memory (scratchpads, vector stores) |
| Goal-based deliberation | Planning prompts, task decomposition, ReAct-style reason-act loops |
| Utility trade-offs | Balancing cost, latency, safety, and success criteria across possible tool sequences |
| Problem generator | Exploratory tool calls — trying a search or a test run to gather information before committing |
One honest caveat: an LLM agent's "model of the world" is implicit in its weights and context rather than an explicit, queryable transition model — which is why LLM agents can fail at consistency tasks a tiny model-based reflex agent handles trivially. For the modern agent stack itself (tool use, MCP, multi-agent orchestration), see the Agentic AI entry.
Practice questions (GATE-style)
- A thermostat turns heating ON when temperature < 18C. What agent type is this? (Answer: Simple reflex agent — it acts only on the current percept with no internal model or goal representation.)
- What is the key difference between goal-based and utility-based agents? (Answer: Goal-based: binary satisfied/not-satisfied. Utility-based: continuous preference score — needed when multiple goals conflict or require trade-offs.)
- A poker-playing AI. Classify its environment completely. (Answer: Partially observable, stochastic, sequential, dynamic, discrete, multi-agent.)
- Name the four components of a learning agent. (Answer: Performance element, Learning element, Critic, Problem generator.)
- Can a simple reflex agent be rational? (Answer: Yes — if the environment is fully observable and the condition-action rules correctly implement the optimal action for each percept.)
- An agent crosses the road after checking traffic, but is hit by debris falling from a building it could not have seen. Was it irrational? (Answer: No — rationality maximizes EXPECTED performance given the percept sequence and prior knowledge. Only omniscience would have avoided the debris, and rationality does not require omniscience.)
- Why does a learning agent need a problem generator when the performance element already selects optimal actions? (Answer: The performance element exploits current knowledge; the problem generator forces exploration — deliberately suboptimal actions that reveal information. Without it the agent never discovers better strategies outside its current policy. This is the classical form of the exploration/exploitation trade-off.)
LumiChats AI Agent mode is a utility-based learning agent: it perceives your task, selects tools (web search, code execution, file I/O), and maximizes task completion. The agent improves its suggestions based on your feedback within a session.