第90章　让 Individual 执行行为

第89章中，Individual 已经完成：

Reasoning → Conclusion → Candidate → Risk → Priority → Decision → Decision Result

但是，Decision 只是“选择”。

例如：

Decision Result

selected = DECELERATE

这并不意味着车辆已经减速。

Individual 必须继续把：

决定 → 行为 → 动作 → 表达 → 模板 → Renderer → Adapter → 外部世界

连接起来，最终让内部决定产生真实的外部效果。

本章建立 Individual 的行为执行链。

1. Decision

Decision 是行为执行的起点。

第89章中，Individual 已经形成：

Decision
    ↓
DECELERATE

例如：

$decision = array(
    'id' => 'decision_001',
    'goal' => 'Vehicle Safety',
    'selected_candidate' => 'candidate_decelerate',
    'state' => 'DECIDED'
);

此时 Individual 已经回答：

应该采取什么方案？

但是还没有回答：

这个方案具体如何执行？

所以需要进入 Behavior。

1.1 Decision 与 Behavior

两者必须保持明确边界：

Decision
=
选择做什么

Behavior
=
组织如何完成这个选择

例如：

Decision:
DECELERATE

对应的 Behavior：

Behavior:
降低 Vehicle_A 当前速度
检查车辆状态
设置目标速度
等待反馈
确认速度变化

因此：

Decision ≠ Behavior

2. Behavior

Behavior 是 Individual 对 Decision 进行执行组织的过程。

它不是一个单独的瞬间动作，而可以包含多个 Action。

例如：

DECELERATE

可以形成：

Behavior
├── 检查车辆状态
├── 设置目标速度
├── 等待车辆响应
├── 获取当前速度
└── 确认减速结果

所以：

Behavior
=
一组具有目标、条件、状态和结果的执行过程

2.1 Behavior 结构

Behavior
├── id
├── type
├── target
├── goal
├── condition
├── actions
├── state
├── result
├── started_at
└── completed_at

例如：

$behavior = array(
    'id' => 'behavior_001',
    'type' => 'DECELERATE',
    'target' => 'Vehicle_A',
    'goal' => 'Reduce Vehicle Speed',
    'condition' => array(
        'state' => 'MOVING'
    ),
    'actions' => array(
        'CHECK_STATE',
        'SET_SPEED',
        'VERIFY_SPEED'
    ),
    'state' => 'READY'
);

2.2 Behavior 生命周期

NEW
 ↓
READY
 ↓
RUNNING
 ↓
WAITING
 ↓
RUNNING
 ↓
SUCCESS

异常情况：

RUNNING
   ↓
FAILED

RUNNING
   ↓
TIMEOUT

RUNNING
   ↓
CONFLICT

RUNNING
   ↓
CANCELLED

Behavior 不应该直接假定执行成功。

必须等待 Action Result 和 Feedback。

3. Action

Action 是 Behavior 中真正需要执行的具体操作。

例如：

Behavior:
DECELERATE

产生：

Action:
SET_SPEED
target = Vehicle_A
value = 20

Action 是：

可以被执行器、设备或外部系统实际执行的具体操作。

3.1 Behavior 与 Action

例如：

Behavior
DECELERATE

可以包含：

Action_001
CHECK_STATE

Action_002
SET_SPEED = 20

Action_003
READ_SPEED

Action_004
VERIFY

因此：

Behavior
   ├── Action
   ├── Action
   ├── Action
   └── Action

核心区别：

Behavior
=
行为过程

Action
=
具体操作

3.2 Action 结构

Action
├── id
├── type
├── target
├── method
├── parameters
├── condition
├── state
└── result

例如：

$action = array(
    'id' => 'action_001',
    'type' => 'EXECUTE',
    'target' => 'Vehicle_A',
    'method' => 'SET_SPEED',
    'parameters' => array(
        'speed' => 20,
        'unit' => 'km/h'
    ),
    'condition' => array(
        'state' => 'MOVING'
    ),
    'state' => 'READY'
);

3.3 Action 生命周期

NEW
 ↓
VALIDATING
 ↓
READY
 ↓
RUNNING
 ↓
SUCCESS

异常：

FAILED
CANCELLED
TIMEOUT
CONFLICT
UNKNOWN

Action 成功只代表：

这个 Action 的执行过程返回了成功结果。

还不一定代表：

外部世界已经达到最终目标。

所以后面还需要 Feedback 和 Verification。

4. Expression

Action 执行之后，Individual 需要把内部结果组织成可以向外部环境传递的结构。

这个过程使用 Expression。

例如 Action Result：

ActionResult

action = SET_SPEED
target = Vehicle_A
state = SUCCESS
output = 20

可以形成：

Expression

type = ACTION_RESULT
target = Vehicle_A
state = SUCCESS
speed = 20

4.1 Expression 的作用

Expression 负责：

把 Individual 内部结果表示成外部接口能够理解的数据。

例如：

ActionResult
     ↓
Expression

Expression 可以表达：

INFORMATION
STATE
ACTION
RESULT
SIGNAL
DATA
STATUS
ERROR

4.2 Expression 不负责执行

Expression 不是 Action。

Action
=
执行什么

Expression
=
把执行结果如何表示出来

因此：

Action ≠ Expression

例如：

Action:
SET_SPEED 20

执行以后：

ActionResult:
SUCCESS

然后：

Expression:
Vehicle_A speed changed to 20

Expression 只是表达结果。

5. Template

Expression 产生之后，SATE 可以使用 Template 对结果进行组织。

核心关系：

Expression
    ↓
Template
    ↓
Renderer

Template 规定：

这些数据按照什么结构排列。

例如 Web Template：

Vehicle Status

Vehicle: {{vehicle.name}}

State: {{vehicle.state}}

Speed: {{vehicle.speed}}

Result: {{result.state}}

Expression 提供：

vehicle.name = Vehicle_A
vehicle.state = MOVING
vehicle.speed = 20
result.state = SUCCESS

Template Engine 将两者结合。

5.1 Template 不进行决策

Template 不负责：

Cognition
Reasoning
Decision
Risk
Learning
Action

它只负责：

数据
+
模板结构
↓
结构化表现

因此：

Template ≠ Intelligence

6. Renderer

Renderer 将 Template 处理后的结构转换成具体表现形式。

例如：

Expression
     ↓
Template
     ↓
WebRenderer
     ↓
HTML

或者：

Expression
     ↓
Template
     ↓
ApiRenderer
     ↓
JSON

或者：

Expression
     ↓
Template
     ↓
DeviceRenderer
     ↓
Device Data

6.1 Renderer 的作用

Renderer 解决：

“以什么形式表现？”

例如：

WebRenderer
→ HTML

ApiRenderer
→ JSON

DeviceRenderer
→ Device Data

Renderer 不应该重新进行：

Reasoning
Decision
Action

所以：

Renderer ≠ Decision
Renderer ≠ Action

7. Adapter

Renderer 完成表现以后，还需要一个机制把结果连接到实际环境。

这个机制就是 Adapter。

核心：

Renderer
   ↓
Rendered Result
   ↓
Adapter
   ↓
External Environment

例如车辆：

Action
   ↓
VehicleAdapter
   ↓
Vehicle Control System
   ↓
Vehicle_A

Web：

WebRenderer
   ↓
HTML
   ↓
WebAdapter
   ↓
Browser

API：

ApiRenderer
   ↓
JSON
   ↓
ApiAdapter
   ↓
External System

7.1 Adapter 的作用

Adapter 解决：

“结果连接到哪里，以及如何与那个环境通信？”

例如：

Renderer
=
转换表现形式

Adapter
=
连接实际环境

所以：

Renderer ≠ Adapter

7.2 VehicleAdapter 实例

继续第89章的车辆案例。

Individual 已经决定：

DECELERATE

Behavior：

DECELERATE

Action：

SET_SPEED
20 km/h

VehicleAdapter 将 Action 转换成车辆控制系统能够接受的命令：

VehicleCommand

device = Vehicle_A
command = SET_SPEED
value = 20
unit = km/h

然后发送：

VehicleAdapter
      ↓
Vehicle Control System
      ↓
Vehicle_A

Adapter 不重新判断：

是否应该减速？

这个问题已经由 Decision 解决。

Adapter 只负责：

把已经确定的 Action 连接到目标环境。

8. External World

External World 是 Individual 所处的真实外部环境。

它可以是：

人
车辆
机器人
工业设备
传感器
Web
API
软件系统
数据系统
物理环境

Individual 的行为最终必须作用于某个外部目标，或者产生外部可观察结果。

8.1 External World 与 Individual

Individual 不是孤立运行的。

完整关系：

Individual
    │
    │ Action
    ▼
Adapter
    │
    ▼
External World
    │
    │ Feedback
    ▼
Individual

这就形成了真正的闭环。

8.2 完整执行案例

继续使用：

Individual_A
Vehicle_A
Obstacle_A

第88章得到：

Reasoning:
risk = HIGH

第89章得到：

Decision:
DECELERATE

现在进入第90章。

第一步：Decision

DecisionResult

selected = DECELERATE
state = DECIDED

↓

第二步：Behavior

Individual 创建：

Behavior_001

type = DECELERATE
target = Vehicle_A
state = READY

↓

第三步：Action

产生具体 Action：

Action_001

method = SET_SPEED

target = Vehicle_A

parameters:
speed = 20
unit = km/h

↓

第四步：Expression

Action 结果需要向外部系统表达：

Expression_001

type = ACTION
target = Vehicle_A
method = SET_SPEED
speed = 20

↓

第五步：Template

使用：

vehicle_command

模板组织：

Vehicle:
{{vehicle}}

Command:
{{command}}

Speed:
{{speed}}

↓

第六步：Renderer

使用：

DeviceRenderer

形成：

VehicleCommand

例如：

{
    "vehicle": "Vehicle_A",
    "command": "SET_SPEED",
    "speed": 20
}

这里的 JSON 只是结构化通信格式，不是推理机制。

↓

第七步：Adapter

VehicleAdapter

接收：

SET_SPEED 20

然后连接：

Vehicle Control System

↓

第八步：External World

真实车辆：

Vehicle_A
40 km/h
   ↓
30 km/h
   ↓
20 km/h

外部世界发生了真实变化。

8.3 Feedback 回到 Individual

执行完成后，车辆返回：

VehicleResponse

vehicle = Vehicle_A
state = SUCCESS
speed = 20

形成：

Feedback

然后重新进入 Individual：

External World
      ↓
Vehicle Response
      ↓
Adapter
      ↓
Feedback
      ↓
Information
      ↓
Perception
      ↓
Cognition
      ↓
Scene Update

于是形成：

                ┌───────────────────────┐
                │       Individual      │
                │                       │
                │ Perception            │
                │ Cognition             │
                │ Reasoning             │
                │ Decision              │
                │ Behavior              │
                │ Action                │
                └───────────┬───────────┘
                            │
                         Expression
                            │
                         Template
                            │
                         Renderer
                            │
                         Adapter
                            │
                            ▼
                    External World
                            │
                         Feedback
                            │
                            ▼
                       Information
                            │
                            └──────────────→ Individual

这才是真正的：

Individual 行为闭环。

本章核心模型

Reasoning
    ↓
Conclusion
    ↓
Decision
    ↓
Decision Result
    ↓
Behavior
    ↓
Action
    ↓
Action Result
    ↓
Expression
    ↓
Template
    ↓
Renderer
    ↓
Rendered Result
    ↓
Adapter
    ↓
External World
    ↓
Feedback
    ↓
Information
    ↓
Perception
    ↓
Cognition

本章核心职责划分

层	核心问题
Decision	应该选择什么？
Behavior	如何组织这个行为过程？
Action	具体执行什么操作？
Expression	如何表示结果或指令？
Template	如何组织表现结构？
Renderer	转换成什么表现形式？
Adapter	连接什么外部环境？
External World	真实发生什么变化？
Feedback	外部世界实际返回什么结果？

因此必须保持：

Decision ≠ Behavior
Behavior ≠ Action
Action ≠ Expression
Expression ≠ Template
Template ≠ Renderer
Renderer ≠ Adapter
Adapter ≠ External World

最终，第90章把 Individual 从：

能够思考、推理、决策

推进到：

能够把自己的决策组织成行为，并通过 Action、Expression、Template、Renderer、Adapter 作用于外部世界，再接收反馈。

最终形成 Individual 的第一个完整闭环：

世界
 ↓
Information
 ↓
Perception
 ↓
Cognition
 ↓
Understanding
 ↓
Memory
 ↓
Reasoning
 ↓
Conclusion
 ↓
Decision
 ↓
Behavior
 ↓
Action
 ↓
Expression
 ↓
Template
 ↓
Renderer
 ↓
Adapter
 ↓
External World
 ↓
Feedback
 ↓
Information

这意味着 Individual 已经不再只是一个内部认知运行体，而成为一个能够“感知世界 → 理解世界 → 推理 → 决策 → 行为 → 作用于世界 → 获得反馈”的闭环个体。

第90章 让 Individual 执行行为

第90章 让 Individual 执行行为

1. Decision

1.1 Decision 与 Behavior

2. Behavior

2.1 Behavior 结构

2.2 Behavior 生命周期

3. Action

3.1 Behavior 与 Action

3.2 Action 结构

3.3 Action 生命周期

4. Expression

4.1 Expression 的作用

4.2 Expression 不负责执行

5. Template

5.1 Template 不进行决策

6. Renderer

6.1 Renderer 的作用

7. Adapter

7.1 Adapter 的作用

7.2 VehicleAdapter 实例

8. External World

8.1 External World 与 Individual

8.2 完整执行案例

第一步：Decision

第二步：Behavior

第三步：Action

第四步：Expression

第五步：Template

第六步：Renderer

第七步：Adapter

第八步：External World

8.3 Feedback 回到 Individual

本章核心模型

本章核心职责划分