この記事の対象読者

AIの定義が曖昧でモヤモヤしている方
「エアコンがAI」と言われて「え？」となった方
Pythonの基本文法（関数、if文）を理解している方
AIエージェントの概念を学びたい初心者〜中級者

この記事で得られること

AI/非AIの境界線を決める公式な判断基準の理解
世界標準のAI教科書（AIMA）に基づいたエージェント分類の知識
PythonでAIエージェントを実装するスキル
「なぜ電卓はAIじゃないのか」を論理的に説明できる力

この記事で扱わないこと

機械学習・深層学習の詳細なアルゴリズム
ChatGPTやLLMの仕組み
数学的な厳密な証明

1. 「エアコンはAIです」と言われた日

「エアコンってAIなんだよ」

先日、AIの入門書を読んでいて、この一文に出会った。正直、最初は「は？」と思った。

エアコンがAI？あの、リモコンでピッとやるやつが？ChatGPTと同じカテゴリ？

一方で、電卓はAIとは呼ばれない。2+2=4を瞬時に計算してくれるのに。

この境界線、めちゃくちゃ曖昧じゃないか？

調べてみると、これはAI研究者の間でも議論されてきた問題だった。そして、世界で最も使われているAI教科書「Artificial Intelligence: A Modern Approach」（通称AIMA）に、その答えが書いてあった。

今回は、この「AIと非AIの境界線」を完全に理解できるよう、AIMA教科書の定義に基づいて徹底解説する。

ここまでで、この記事のテーマがなんとなく見えてきただろうか。次は、議論の土台となる用語を整理していこう。

2. 前提知識の確認

本題に入る前に、この記事で使う用語を整理しておく。

2.1 AI（人工知能）とは

人間が行う知的な活動を、コンピュータで実現する技術の総称。「知能」の定義自体が曖昧なため、AIの範囲も時代とともに変化してきた。

2.2 エージェントとは

環境を「知覚」（センシング）し、その環境に「作用」（アクション）するもの。人間もロボットもソフトウェアも、すべてエージェントとして捉えられる。

2.3 AIMA教科書とは

Stuart RussellとPeter Norvigによる「Artificial Intelligence: A Modern Approach」のこと。世界1500以上の大学で採用されている、AI分野の標準的な教科書。本記事の議論はこの教科書に基づく。

これらの用語を押さえたところで、AIMAが定義する「エージェント」の概念を見ていこう。

3. AIMAが定義する「エージェント」とは

3.1 エージェントの基本定義

AIMAでは、エージェントを次のように定義している。

An agent is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.
（エージェントとは、センサーを通じて環境を知覚し、アクチュエータを通じてその環境に作用するものすべてである）

— Russell & Norvig, "Artificial Intelligence: A Modern Approach" 4th Edition, Chapter 2

つまり、エージェントには以下の4要素が必要だ。

要素	説明	例（人間）	例（エアコン）
センサー	環境を知覚する	目、耳、皮膚	温度センサー
アクチュエータ	環境に作用する	手、足、声	コンプレッサー、ファン
環境	エージェントが存在する場	物理世界	室内空間
知覚（Percept）	センサーからの入力	視覚情報	現在の室温

3.2 電卓をエージェントとして見ると？

ここで重要な記述がある。AIMAの著者は、電卓について次のように述べている。

One could view a hand-held calculator as an agent that chooses the action of displaying "4" when given the percept sequence "2 + 2 =," but such an analysis would hardly aid our understanding of the calculator.
（電卓を「2+2=」という知覚シーケンスに対して「4を表示する」という行動を選ぶエージェントとして見ることもできるが、そのような分析は電卓の理解に役立たない）

— Russell & Norvig, AIMA 4th Edition, Chapter 2

つまり、電卓もエージェントとして「見ることはできる」が、そう見ても意味がないというのがAIMAの立場だ。

抽象的な定義を理解したところで、次はなぜエアコンはAIエージェントとして有用で、電卓はそうでないのか、具体的に見ていこう。

4. エアコンはAI、電卓は非AI。その決定的な違い

4.1 AIMAにおけるサーモスタットの位置づけ

AIMAでは、サーモスタット（エアコンの制御部分）を明確に「Simple Reflex Agent（単純反射エージェント）」として分類している。

A home thermostat, which turns on or off when the temperature drops below a certain point, is an example of a simple reflex agent.
（温度が一定以下に下がるとオン/オフするホームサーモスタットは、単純反射エージェントの例である）

— Russell & Norvig, AIMA 4th Edition, Chapter 2

4.2 決定的な違いは「フィードバックループ」

エアコンと電卓の最大の違いは、環境との継続的な相互作用の有無だ。

特性	エアコン	電卓
環境のセンシング	室温を継続的に監視	なし（ボタン入力のみ）
目標	設定温度の維持	なし（計算結果を返すだけ）
フィードバックループ	あり（温度→判断→動作→温度...）	なし（入力→計算→出力で完結）
自律的な行動	あり（温度に応じて自動調整）	なし（人間の入力待ち）
環境への影響	あり（室温を変化させる）	なし（表示するだけ）

4.3 図解：エージェントとしての違い

【エアコン（エージェントとして有用）】

    ┌──────────────────────────────────┐
    │            環境（室内）           │
    │                                  │
    │   現在の室温: 28°C              │
    │         ↓ センシング            │
    │   ┌──────────────┐              │
    │   │   エアコン    │              │
    │   │  目標: 25°C  │              │
    │   │   判断: 冷房ON │             │
    │   └──────────────┘              │
    │         ↓ 作用                  │
    │   室温を下げる → 26°C → 25°C   │
    │         ↓                       │
    │   目標達成 → 停止               │
    └──────────────────────────────────┘
    
    → フィードバックループが存在する


【電卓（エージェントとして見ても無意味）】

    人間 → [2][+][2][=] → 電卓 → [4] → 人間
    
    入力 → 処理 → 出力（1回で完結、環境に影響なし）

4.4 「分析の有用性」という判断基準

AIMAの著者が言っているのは、エージェントの定義は「世界を分析するためのツール」であり、絶対的な分類ではないということだ。

エアコンをエージェントとして分析すると、制御の仕組みが理解しやすくなる
電卓をエージェントとして分析しても、特に新しい理解は得られない

この「分析上の有用性」が、AI/非AIの境界線を実質的に決めている。

ここまでで抽象的な境界線の基準がわかった。次は、AIMAが定義する5種類のエージェントを見て、より具体的な分類を理解しよう。

5. AIMAが定義する5種類のエージェント

AIMAでは、エージェントを知能の高さに応じて5段階に分類している。

5.1 エージェント分類一覧

レベル	名称	特徴	具体例
1	Simple Reflex Agent	現在の知覚のみで行動を決定	サーモスタット、自動ドア
2	Model-based Reflex Agent	内部状態を持ち、見えない部分を推測	車のクルーズコントロール
3	Goal-based Agent	目標を持ち、達成のために行動を選択	経路探索ナビ
4	Utility-based Agent	効用関数で「最適」な行動を選択	自動運転車
5	Learning Agent	経験から学習して性能を向上	ChatGPT、AlphaGo

5.2 各エージェントの詳細

Level 1: Simple Reflex Agent（単純反射エージェント）

「IF 条件 THEN 行動」のルールで動作する最もシンプルなエージェント。

IF 温度 < 設定温度 THEN 暖房ON
IF 温度 > 設定温度 THEN 冷房ON

特徴: 過去の情報を記憶しない。現在の知覚だけで判断する。

限界: 環境が完全に観測可能でないと、無限ループに陥ることがある。

Level 2: Model-based Reflex Agent（モデルベース反射エージェント）

内部状態を持ち、「世界がどう変化するか」のモデルを使って判断する。

特徴: 見えない部分を推測できる。前の車のブレーキランプの変化を記憶し、「減速中」と判断できる。

Level 3: Goal-based Agent（目標ベースエージェント）

明確な目標を持ち、その達成のために行動を計画する。

特徴: 「目的地に到着する」という目標に向けて、複数の行動を組み合わせられる。

Level 4: Utility-based Agent（効用ベースエージェント）

目標の達成だけでなく、「どの程度良いか」を数値化して最適な行動を選ぶ。

特徴: 「安全」と「速さ」のトレードオフを考慮できる。

Level 5: Learning Agent（学習エージェント）

経験から学習し、自身の性能を向上させる。

特徴: 初期状態では知識が不完全でも、学習によって改善できる。

分類の全体像を把握したところで、次は実際にPythonでSimple Reflex Agentを実装して、理論を具体的なコードに落とし込んでみよう。

6. Pythonで実装する「Simple Reflex Agent」

6.1 環境構築

以下のコードは標準ライブラリのみで動作する。追加のパッケージは不要だ。

# Pythonバージョン確認（3.8以上推奨）
python --version

6.2 実装コード（コピペで動作）

"""
Simple Reflex Agent - サーモスタットシミュレーション
このファイルをコピペして実行すれば、AIエージェントの基本動作が確認できる。

使い方:
    python thermostat_agent.py
"""

from dataclasses import dataclass
from typing import Literal
import random


# --- 設定ファイルの代替：設定クラス ---
@dataclass
class Config:
    """サーモスタットエージェントの設定"""
    target_temperature: float  # 目標温度
    tolerance: float          # 許容誤差
    initial_temperature: float  # 初期室温
    simulation_steps: int      # シミュレーションステップ数
    

# --- 環境別設定テンプレート ---

# 開発環境用（デバッグしやすい設定）
CONFIG_DEV = Config(
    target_temperature=25.0,
    tolerance=1.0,
    initial_temperature=20.0,
    simulation_steps=10
)

# 本番環境用（現実的な設定）
CONFIG_PROD = Config(
    target_temperature=25.0,
    tolerance=0.5,
    initial_temperature=30.0,
    simulation_steps=50
)

# テスト環境用（高速に完了する設定）
CONFIG_TEST = Config(
    target_temperature=25.0,
    tolerance=2.0,
    initial_temperature=24.0,
    simulation_steps=5
)


# --- 型定義 ---
Action = Literal["HEAT", "COOL", "OFF"]
Percept = float  # 室温


class Environment:
    """室内環境のシミュレーション"""
    
    def __init__(self, initial_temp: float):
        self.temperature = initial_temp
        self.outside_temp = 15.0  # 外気温（固定）
    
    def get_percept(self) -> Percept:
        """現在の室温を返す（センサー）"""
        return self.temperature
    
    def apply_action(self, action: Action) -> None:
        """エージェントの行動を環境に反映（アクチュエータ）"""
        if action == "HEAT":
            self.temperature += 2.0
        elif action == "COOL":
            self.temperature -= 2.0
        else:  # OFF
            # 外気温に向かってゆっくり変化
            diff = self.outside_temp - self.temperature
            self.temperature += diff * 0.1
        
        # ノイズを追加（現実世界の不確実性をシミュレート）
        self.temperature += random.uniform(-0.3, 0.3)


class SimpleReflexAgent:
    """
    単純反射エージェント（サーモスタット）
    
    このエージェントは、現在の知覚（室温）のみに基づいて行動を決定する。
    過去の情報は記憶しない。
    """
    
    def __init__(self, target_temp: float, tolerance: float):
        self.target_temp = target_temp
        self.tolerance = tolerance
    
    def select_action(self, percept: Percept) -> Action:
        """
        条件-行動ルールに基づいて行動を選択
        
        ルール:
            IF 室温 < 目標温度 - 許容誤差 THEN 暖房ON
            IF 室温 > 目標温度 + 許容誤差 THEN 冷房ON
            OTHERWISE 停止
        """
        if percept < self.target_temp - self.tolerance:
            return "HEAT"
        elif percept > self.target_temp + self.tolerance:
            return "COOL"
        else:
            return "OFF"


def run_simulation(config: Config) -> list[dict]:
    """
    シミュレーションを実行し、結果を返す
    
    Args:
        config: シミュレーション設定
        
    Returns:
        各ステップの状態を記録したリスト
    """
    # 環境とエージェントを初期化
    env = Environment(config.initial_temperature)
    agent = SimpleReflexAgent(config.target_temperature, config.tolerance)
    
    history = []
    
    for step in range(config.simulation_steps):
        # 1. エージェントが環境を知覚
        percept = env.get_percept()
        
        # 2. エージェントが行動を決定
        action = agent.select_action(percept)
        
        # 3. 状態を記録
        history.append({
            "step": step,
            "temperature": round(percept, 2),
            "action": action,
            "target": config.target_temperature
        })
        
        # 4. 環境に行動を適用
        env.apply_action(action)
    
    return history


def print_results(history: list[dict]) -> None:
    """結果を見やすく表示"""
    print("\n" + "=" * 50)
    print("Simple Reflex Agent シミュレーション結果")
    print("=" * 50)
    print(f"{'Step':<6}{'温度':<10}{'行動':<8}{'目標':<8}")
    print("-" * 50)
    
    for record in history:
        temp_str = f"{record['temperature']:.1f}°C"
        action_jp = {"HEAT": "暖房", "COOL": "冷房", "OFF": "停止"}
        print(f"{record['step']:<6}{temp_str:<10}{action_jp[record['action']]:<8}{record['target']}°C")
    
    print("=" * 50)


if __name__ == "__main__":
    # 使用する設定を選択（DEV / PROD / TEST）
    config = CONFIG_DEV
    
    print(f"設定: 目標温度={config.target_temperature}°C, 初期温度={config.initial_temperature}°C")
    
    # シミュレーション実行
    history = run_simulation(config)
    
    # 結果表示
    print_results(history)

6.3 実行結果

上記のコードを実行すると、以下のような出力が得られる。

設定: 目標温度=25.0°C, 初期温度=20.0°C

==================================================
Simple Reflex Agent シミュレーション結果
==================================================
Step  温度        行動      目標    
--------------------------------------------------
0     20.0°C     暖房      25.0°C
1     21.8°C     暖房      25.0°C
2     23.9°C     暖房      25.0°C
3     25.7°C     冷房      25.0°C
4     23.5°C     暖房      25.0°C
5     25.3°C     停止      25.0°C
6     24.8°C     停止      25.0°C
7     24.5°C     停止      25.0°C
8     24.1°C     暖房      25.0°C
9     26.2°C     冷房      25.0°C
==================================================

6.4 トラブルシューティング

エラー	原因	対処法
`ModuleNotFoundError: dataclasses`	Python 3.6以下を使用	Python 3.7以上にアップグレード
`SyntaxError: invalid syntax`	Python 2系を使用	`python3`コマンドで実行
`TypeError: 'type' object is not subscriptable`	Python 3.8以下で`list[dict]`を使用	Python 3.9以上にアップグレード、または`from __future__ import annotations`を追加

コードで基本動作を理解したところで、次はより実践的なユースケースを見ていこう。

7. ユースケース別ガイド

7.1 ユースケース1: IoTデバイスの制御ロジック実装

想定読者: スマートホームデバイスの開発者

推奨構成: Simple Reflex Agentをベースに、センサーとアクチュエータを抽象化

サンプルコード:

"""
IoTデバイス用の汎用エージェントフレームワーク
"""

from abc import ABC, abstractmethod
from typing import Any


class Sensor(ABC):
    """センサーの抽象クラス"""
    
    @abstractmethod
    def read(self) -> Any:
        """センサー値を読み取る"""
        pass


class Actuator(ABC):
    """アクチュエータの抽象クラス"""
    
    @abstractmethod
    def execute(self, action: str) -> None:
        """行動を実行する"""
        pass


class IoTAgent:
    """IoTデバイス用Simple Reflex Agent"""
    
    def __init__(self, sensor: Sensor, actuator: Actuator, rules: dict):
        self.sensor = sensor
        self.actuator = actuator
        self.rules = rules  # {条件関数: 行動} の辞書
    
    def step(self) -> str:
        """1ステップ実行"""
        percept = self.sensor.read()
        
        for condition, action in self.rules.items():
            if condition(percept):
                self.actuator.execute(action)
                return action
        
        return "NO_ACTION"


# --- 具体的な実装例：照明センサー ---

class LightSensor(Sensor):
    """照度センサー"""
    
    def __init__(self, initial_lux: float = 500):
        self.lux = initial_lux
    
    def read(self) -> float:
        return self.lux


class LightActuator(Actuator):
    """照明アクチュエータ"""
    
    def __init__(self):
        self.state = "OFF"
    
    def execute(self, action: str) -> None:
        self.state = action
        print(f"照明: {action}")


if __name__ == "__main__":
    sensor = LightSensor(initial_lux=200)  # 暗い
    actuator = LightActuator()
    
    rules = {
        lambda lux: lux < 300: "ON",   # 暗ければ点灯
        lambda lux: lux >= 300: "OFF"  # 明るければ消灯
    }
    
    agent = IoTAgent(sensor, actuator, rules)
    action = agent.step()
    print(f"実行された行動: {action}")

7.2 ユースケース2: ゲームAIの敵キャラクター

想定読者: ゲーム開発者

推奨構成: Goal-based Agentに拡張して、プレイヤーを追いかける

サンプルコード:

"""
ゲームAI用の敵キャラクターエージェント
"""

from dataclasses import dataclass
from enum import Enum
import math


class Action(Enum):
    MOVE_UP = "UP"
    MOVE_DOWN = "DOWN"
    MOVE_LEFT = "LEFT"
    MOVE_RIGHT = "RIGHT"
    ATTACK = "ATTACK"
    IDLE = "IDLE"


@dataclass
class Position:
    x: float
    y: float
    
    def distance_to(self, other: "Position") -> float:
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)


class EnemyAgent:
    """
    Goal-based Agent: プレイヤーを追跡する敵キャラクター
    
    目標: プレイヤーに近づいて攻撃する
    """
    
    def __init__(self, position: Position, attack_range: float = 1.5):
        self.position = position
        self.attack_range = attack_range
        self.goal = "CHASE_PLAYER"
    
    def select_action(self, player_pos: Position) -> Action:
        """目標に基づいて行動を選択"""
        distance = self.position.distance_to(player_pos)
        
        # 攻撃範囲内なら攻撃
        if distance <= self.attack_range:
            return Action.ATTACK
        
        # そうでなければ追跡
        dx = player_pos.x - self.position.x
        dy = player_pos.y - self.position.y
        
        # より大きい差がある方向に移動
        if abs(dx) > abs(dy):
            return Action.MOVE_RIGHT if dx > 0 else Action.MOVE_LEFT
        else:
            return Action.MOVE_DOWN if dy > 0 else Action.MOVE_UP


if __name__ == "__main__":
    enemy = EnemyAgent(Position(0, 0))
    player = Position(5, 3)
    
    print(f"敵の位置: ({enemy.position.x}, {enemy.position.y})")
    print(f"プレイヤーの位置: ({player.x}, {player.y})")
    
    action = enemy.select_action(player)
    print(f"選択された行動: {action.value}")

7.3 ユースケース3: チャットボットの応答制御

想定読者: チャットボット開発者

推奨構成: ルールベースのSimple Reflex Agentから始めて、Learning Agentに拡張

サンプルコード:

"""
チャットボット用のルールベースエージェント
"""

import re
from dataclasses import dataclass


@dataclass
class Rule:
    """条件-行動ルール"""
    pattern: str  # 正規表現パターン
    response: str  # 応答テンプレート


class ChatbotAgent:
    """
    Simple Reflex Agent: ルールベースのチャットボット
    
    ルールにマッチしたら、対応する応答を返す。
    """
    
    def __init__(self, rules: list[Rule], default_response: str):
        self.rules = rules
        self.default_response = default_response
    
    def respond(self, user_input: str) -> str:
        """ユーザー入力に対する応答を生成"""
        input_lower = user_input.lower()
        
        for rule in self.rules:
            if re.search(rule.pattern, input_lower):
                return rule.response
        
        return self.default_response


if __name__ == "__main__":
    rules = [
        Rule(r"こんにちは|hello|hi", "こんにちは！何かお手伝いできますか？"),
        Rule(r"ありがとう|thanks", "どういたしまして！"),
        Rule(r"天気", "今日は晴れの予報です。"),
        Rule(r"bye|さようなら", "またお会いしましょう！"),
    ]
    
    bot = ChatbotAgent(rules, "すみません、よくわかりませんでした。")
    
    # テスト
    test_inputs = ["こんにちは", "今日の天気は？", "明日の予定", "ありがとう"]
    
    for user_input in test_inputs:
        response = bot.respond(user_input)
        print(f"ユーザー: {user_input}")
        print(f"ボット: {response}")
        print("-" * 30)

ユースケース別の実装パターンを理解したところで、次にこの記事を読んだ後の学習パスを確認しよう。

8. 学習ロードマップ

この記事を読んだ後、次のステップとして以下をおすすめする。

初級者向け（まずはここから）

AIMAの日本語解説を読む
- Qiita: AIMA解説シリーズで日本語の解説記事を探す
- Chapter 2（Intelligent Agents）が本記事の内容に対応
OpenAI Gymで強化学習入門
- Gymnasium公式ドキュメント
- シンプルな環境でエージェントの学習を体験

中級者向け（実践に進む）

Model-based Agentを実装
- 本記事のコードを拡張して、内部状態を持つエージェントを作成
- 「見えない部分を推測する」ロジックを追加
強化学習フレームワークを使う
- Stable Baselines3でDQNやPPOを試す
- Learning Agentの実装を体験

上級者向け（さらに深く）

AIMA原著を読む
- 公式サイトからサンプルコードをダウンロード
- 英語だが、世界標準の知識が得られる
マルチエージェントシステムを学ぶ
- 複数のエージェントが相互作用する環境
- ゲーム理論との接点

9. まとめ

この記事では、「AIと非AIの境界線」について、AIMA教科書の定義に基づいて解説した。

要点の整理

エージェントの定義: 環境をセンシングし、環境に作用するもの
AI/非AIの境界: 厳密な線引きではなく、分析上の有用性で決まる
電卓がAIでない理由: エージェントとして見ても理解が深まらない
エアコンがAIである理由: Simple Reflex Agentとして分析すると制御の仕組みが理解しやすい
5種類のエージェント: Simple Reflex → Model-based → Goal-based → Utility-based → Learning

私の所感

正直、この境界線の曖昧さには最初戸惑った。「AIかどうか」に明確なYes/Noがあると思っていたからだ。

しかし、Russell & Norvigの「分析のためのツール」という視点は、実務でも役立つ考え方だと思う。技術を理解するとき、「これはAIか？」という問いより「これをエージェントとして見ると何がわかるか？」という問いの方が、実りがある。

「エアコンはAI」という一文に引っかかったあの日から、AIの定義についてかなり理解が深まった。この記事が、同じモヤモヤを抱えている人の助けになれば幸いだ。

参考文献

Russell, S. J., & Norvig, P. (2020). Artificial Intelligence: A Modern Approach (4th ed.). Pearson.
- 公式サイト
- Chapter 2 PDF（Intelligent Agents）
Wikipedia. "Intelligent agent."
- https://en.wikipedia.org/wiki/Intelligent_agent