Agent Architecture

A reactive architecture is a stimulus-response design where an agent's actions are direct, pre-programmed functions of its current sensory inputs, with no internal symbolic world model or complex planning. These agents operate on condition-action rules (if-then rules).

• Key Mechanism: Uses a production system where sensor data is matched against a rule base to trigger an immediate action.
• Characteristics: Fast, simple, and robust in predictable environments but limited in handling novel situations requiring foresight.
• Example: A robotic vacuum cleaner that turns upon detecting an obstacle or a thermostat that activates heating when temperature drops below a set point.

A deliberative architecture is a model-based design where an agent maintains an internal symbolic representation of the world, uses logical reasoning to form plans, and then executes those plans to achieve its goals. It embodies the sense-plan-act cycle.

• Key Mechanism: Incorporates a knowledge base (beliefs), a goal set, and a planner to generate sequences of actions.
• Characteristics: Capable of complex, goal-directed behavior in dynamic environments but can suffer from computational complexity and the frame problem (representing what changes and what stays the same).
• Example: An autonomous delivery robot that plans an optimal route across a warehouse map, accounting for dynamic obstacles and battery levels.

The Belief-Desire-Intention (BDI) model is a prominent practical reasoning architecture where an agent's behavior is governed by its Beliefs (information about the world), Desires (potential goals), and Intentions (committed plans chosen to achieve desires).

• Key Mechanism: Operates through a continuous reasoning loop: perceive (update beliefs), deliberate (filter desires to generate intentions), and act (execute intention plans).
• Characteristics: Balances reactivity (by re-evaluating intentions) with goal-directedness, making it suitable for complex, dynamic environments like air traffic control or manufacturing scheduling.
• Foundation: Based on the philosophical theory of practical reasoning by Michael Bratman.

A hybrid architecture combines reactive and deliberative components within a single agent to leverage the speed of reaction and the foresight of planning. It typically uses a layered approach to manage different levels of behavioral complexity.

• Common Pattern: The three-layer architecture, consisting of a reactive execution layer, a deliberative planning layer, and a middle sequencing layer to manage and resolve conflicts between the other two.
• Characteristics: Provides robustness and flexibility, allowing the agent to handle routine tasks reactively while reserving planning for novel, strategic problems. Complexity lies in designing effective inter-layer communication.
• Example: An autonomous vehicle that reactively brakes for a sudden obstacle (reactive layer) while concurrently re-planning its overall route due to a traffic alert (deliberative layer).

Subsumption architecture is a behavior-based, reactive paradigm where an agent's overall intelligence emerges from the interaction of simpler, independent behavior modules arranged in a hierarchy of increasing competence.

• Key Mechanism: Lower layers (e.g., avoid-obstacles) implement basic behaviors. Higher layers (e.g., explore) subsume or inhibit the outputs of lower layers to achieve more complex goals. There is no central world model.
• Characteristics: Highly robust and modular, inspired by insect ethology. It excels in real-time, dynamic physical environments but is less suited for tasks requiring symbolic knowledge or long-term planning.
• Origin: Pioneered by Rodney Brooks at MIT for mobile robotics in the 1980s.

A utility-based architecture is a decision-theoretic model where an agent selects actions designed to maximize the expected value of a utility function, which quantitatively represents its preferences over possible world states.

• Key Mechanism: The agent evaluates potential actions by modeling their likely outcomes (often using probability) and calculating the expected utility of each, choosing the action with the highest value.
• Characteristics: Provides a principled framework for making rational decisions under uncertainty and for trading off between competing goals. It is computationally intensive and requires a well-defined utility model.
• Application: Found in economic agents, complex game AI, and any system where decisions involve probabilistic outcomes and nuanced preferences.

An intelligent agent is the core autonomous entity defined by an architecture. It is a software system situated in an environment that perceives through sensors, reasons using internal models or learned policies, and acts through effectors to achieve goals.

• Key Components: Sensors, effectors, a reasoning engine, and a knowledge base.
• Architectural Role: The intelligent agent is the instantiated unit built according to an architectural blueprint (e.g., reactive, BDI, hybrid).
• Example: A delivery robot using LiDAR (sensor), a path-planning algorithm (reasoning), and motor controls (effector) to navigate a warehouse.

The Belief-Desire-Intention (BDI) model is a prominent, deliberative software architecture for intelligent agents based on the philosophical theory of practical reasoning.

• Beliefs: The agent's knowledge about the world (its internal model).
• Desires: The agent's objectives or goals.
• Intentions: The specific plans or courses of action the agent has committed to executing.
• Architectural Role: Provides a structured framework for building agents that plan ahead, replan on failure, and reason about their goals. It contrasts with simpler reactive architectures.

The agent reasoning engine is the core computational component within an intelligent agent's architecture that performs logical inference, planning, or decision-making.

• Function: Processes the agent's beliefs (current state), goals, and perceived environment to select actions or generate plans.
• Implementation Types: Can be a symbolic planner (e.g., using PDDL), a rule-based inference engine, or a learned policy model (e.g., a neural network in a reinforcement learning agent).
• Architectural Role: This is the 'brain' of a deliberative or hybrid agent, directly implementing the decision-making logic specified by the architecture.

A reactive architecture is an agent design paradigm where behavior is determined by direct mapping from sensory inputs to actions, with no internal symbolic world model or complex planning.

• Principle: Sense → Act. Uses condition-action rules (if-then).
• Characteristics: Fast, simple, robust in dynamic environments, but limited in handling novel situations requiring foresight.
• Architectural Role: Represents one end of the architectural spectrum. Often combined with deliberative components in hybrid architectures to balance speed with reasoning capability.
• Example: A vacuum cleaning robot that simply turns right when it bumps into an obstacle.

A hybrid architecture combines reactive and deliberative components within a single agent to leverage the speed of reactive responses and the foresight of goal-based planning.

• Common Pattern: A multi-layer architecture, such as a three-layer system:
  • Reactive Layer: Fast, low-level control loops.
  • Deliberative Layer: Slower, planning and goal management.
  • Sequencing Layer: Mediates between the two, deciding which layer controls action at any given time.
• Architectural Role: The dominant paradigm for complex agents operating in real-world, dynamic environments (e.g., autonomous vehicles, advanced robotics).

An agent policy is the rule, function, or strategy that defines the agent's behavior, mapping its perceived state to its chosen actions.

• Formal Definition: Denoted as π(state) → action.
• Types: Can be deterministic (one action per state) or stochastic (a probability distribution over actions).
• Implementation: In reactive agents, it's a set of hand-coded rules. In learning agents (e.g., using reinforcement learning), it is a learned function (like a neural network) optimized for reward.
• Architectural Role: The policy is the executable manifestation of the agent's decision-making logic, whether simple (reactive) or complex (deliberative/learned).