A modern approach.

.gitignore

@@ -76,3 +76,6 @@ target/
 # for macOS
 .DS_Store
 ._.DS_Store
+
+.venv
+.venv310

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "aima-data"]
 	path = aima-data
 	url = https://github.com/aimacode/aima-data.git
+[submodule "aima-pseudocode"]
+	path = aima-pseudocode
+	url = https://github.com/aimacode/aima-pseudocode

agents.ipynb

@@ -28,6 +28,7 @@
     "* Overview\n",
     "* Agent\n",
     "* Environment\n",
+    "* Agent Architectures\n",
     "* Simple Agent and Environment\n",
     "* Agents in a 2-D Environment\n",
     "* Wumpus Environment\n",
@@ -103,6 +104,107 @@
     "* `execute_action(self, agent, action)`: The environment reacts to an action performed by a given agent. The changes may result in agent experiencing new percepts or other elements reacting to agent input."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## AGENT ARCHITECTURES\n",
+    "\n",
+    "In this section, we'll explore the different types of agent architectures described in Chapter 2 of the AIMA book. These architectures represent different ways an agent can process percepts and select actions.\n",
+    "\n",
+    "### Table-Driven Agent\n",
+    "\n",
+    "A table-driven agent uses a lookup table that maps every possible percept sequence to an action. This approach is only practical for very small domains because the table grows exponentially with the length of the percept sequence.\n",
+    "\n",
+    "The `TableDrivenAgentProgram` function implements this architecture as shown in **Figure 2.7** of the book."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "psource(TableDrivenAgentProgram)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simple Reflex Agent\n",
+    "\n",
+    "A simple reflex agent selects actions based only on the current percept, ignoring the rest of the percept history. These agents work on **condition-action rules** (also called **situation-action rules**, **productions**, or **if-then rules**), which tell the agent what action to take when a particular situation is encountered.\n",
+    "\n",
+    "The schematic diagram shown in **Figure 2.10** of the book illustrates this architecture:\n",
+    "\n",
+    "![Simple Reflex Agent](images/simple_reflex_agent.jpg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "psource(SimpleReflexAgentProgram)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model-Based Reflex Agent\n",
+    "\n",
+    "A model-based reflex agent maintains an **internal state** that depends on the percept history and reflects at least some of the unobserved aspects of the current state. In addition to this, it requires a **model** of the world\u2014knowledge about \"how the world works\"\u2014including:\n",
+    "\n",
+    "* How the world evolves independently of the agent\n",
+    "* How the agent's actions affect the world\n",
+    "\n",
+    "The schematic diagram shown in **Figure 2.12** of the book illustrates this architecture:\n",
+    "\n",
+    "![Model-Based Reflex Agent](images/model_based_reflex_agent.jpg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "psource(ModelBasedReflexAgentProgram)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Goal-Based Agent\n",
+    "\n",
+    "A goal-based agent needs **goal** information that describes desirable situations. The agent program can combine this with information about the results of possible actions (the model) to choose actions that achieve the goal. This makes the agent more flexible because the knowledge that supports its decisions is represented explicitly and can be modified.\n",
+    "\n",
+    "The schematic diagram shown in **Figure 2.13** of the book illustrates a model-based, goal-based agent:\n",
+    "\n",
+    "![Goal-Based Agent](images/model_goal_based_agent.jpg)\n",
+    "\n",
+    "**Search** (Chapters 3 to 5) and **Planning** (Chapters 10 to 11) are the subfields of AI devoted to finding action sequences that achieve the agent's goals."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Utility-Based Agent\n",
+    "\n",
+    "Goals alone are not always enough to generate high-quality behavior. For example, there may be many action sequences that achieve the goal, but some are better, faster, safer, or more reliable than others. A utility-based agent uses a **utility function** that maps a state (or a sequence of states) onto a real number describing the associated degree of happiness.\n",
+    "\n",
+    "The schematic diagram shown in **Figure 2.14** of the book illustrates a model-based, utility-based agent:\n",
+    "\n",
+    "![Utility-Based Agent](images/model_utility_based_agent.jpg)\n",
+    "\n",
+    "A complete utility-based agent chooses the action that maximizes the expected utility of the action outcomes\u2014that is, what the agent expects to achieve, given the probabilities and utilities of each outcome."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -732,4 +834,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
+}