ClawKeeper 深度解析：当「用智能体监管智能体」从概念走向工程——三层防御架构如何为 OpenClaw 系上数字安全带
前言：AI 助手正在变成系统级的「超级用户」
2026 年的开源 AI 生态，正在经历一场深刻的范式转变。
从早期的「对话式 AI」到如今的「行动型 Agent」，OpenClaw 这类平台已经将 AI 从一个只会「说」的工具，升级为一个能够「做」的系统级助手——读写文件、执行命令、调用工具、操作浏览器、管理节点……当 AI 拥有了这些能力，它就不再只是一个聊天机器人，而是一个拥有真实系统权限的「超级用户」。
然而，拥有权力的同时，也意味着拥有风险。
2026 年 4 月初，OpenClaw 连续被曝出多个高危漏洞，其中 CVE-2026-33579 的 CVSS 评分高达 9.8（满分 10），攻击者只需持有最低级别的「配对权限」，就能在几秒内完成权限提升，直接接管整个 OpenClaw 实例。这一漏洞的影响范围覆盖了全球超过 42,000 个暴露在公网上的 OpenClaw 实例，攻击者可以借此访问本地文件、窃取 API 凭证、甚至操控已连接的 Slack、Discord 等外部服务。
这还不是孤例。回顾 2026 年 3 月，OpenClaw 还先后被曝出：
- CVE-2026-329XX 系列（CVSS 10.0 满分）：WebSocket 无认证升级漏洞，所有 < 2026.3.22 的版本均受影响，未授权连接即可获取系统最高权限
- CVE-2026-32914（CVSS 8.7）：未授权访问漏洞，攻击者可读取和篡改系统关键配置
- CVE-2026-32846：媒体解析路径遍历漏洞，可导致文件读取
- Gateway node.invoke 远程代码执行漏洞：可直接在主机上执行任意代码
这些漏洞的共同特点是：它们都利用了 OpenClaw 作为「行动型 Agent」所拥有的超高权限。在传统应用安全领域，一个聊天机器人的 XSS 漏洞可能只是弹个框；但在 Agent 时代，同样的漏洞可能意味着服务器被接管、数据被清空、凭证被窃取。
面对这一现状，传统的安全方案显得力不从心——杀毒软件不知道如何扫描 Agent 的行为轨迹，防火墙不知道如何过滤来自 AI 的「合法但危险」的系统调用，大多数安全工具甚至根本没有「AI 行为监控」的概念。
正是在这一背景下，2026 年 4 月 10 日，北京智源人工智能研究院、北京邮电大学与中国信息通信研究院联合发布了 ClawKeeper v1.0——一个面向 OpenClaw 的全方位实时安全框架。论文发表于 arXiv（编号：arXiv:2603.24414v1），已在 GitHub 开源。
ClawKeeper 的核心创新，用一句话概括就是：用智能体监管智能体。
这不是一个简单的「在 Agent 外面套个壳」的安全方案，而是一套精心设计的三层防御架构——Skill-based（技能级防护）、Plugin-based（插件级防护） 和 Watcher-based（监管者级防护），从指令层、运行时到系统层，构建了一套覆盖智能体全生命周期的安全基础设施。
本文将深入解析 ClawKeeper 的设计哲学、架构细节、实现机制，并探讨它对整个 AI Agent 安全领域的启示。
第一章：威胁建模——OpenClaw 的安全困境究竟有多特殊？
要理解 ClawKeeper 为什么这样设计，我们首先需要理解 OpenClaw 面临的安全挑战与传统的应用安全有何本质不同。
1.1 从「内容问题」到「系统问题」
传统 AI 安全问题的核心是「内容安全」：幻觉、有害内容、隐私泄露……但这些问题的边界是清晰的——AI 说错了话，删除对话记录即可；AI 泄露了隐私，撤回消息即可。影响的本质是信息层面。
但 OpenClaw 这类行动型 Agent 的安全问题，已经从「内容问题」升级为「系统问题」：
传统 AI 安全：
用户 → AI（生成内容） → 撤回/删除
OpenClaw 安全：
用户 → AI（执行操作） → 读写文件/运行命令/访问网络 → 系统被入侵
当 AI 可以直接调用 exec 工具执行 shell 命令时，一次提示词注入攻击的后果就不再是「AI 说了一句错话」，而是「攻击者在你的服务器上获得了一个 shell」。当 AI 可以读取文件系统时，一次提示词注入的结果就不再是「AI 告诉你一个假消息」，而是「攻击者拿到了你的 SSH 私钥」。
这就是 OpenClaw 安全的本质：信任边界发生了根本性位移。
在传统软件架构中，信任边界通常由操作系统边界、进程边界、容器边界来定义。但在 OpenClaw 中，信任边界延伸到了 AI 的「意图理解层」——系统需要假设 AI 能够正确理解用户意图、正确评估操作风险、正确拒绝恶意指令。这在传统安全模型中是完全陌生的命题。
1.2 OpenClaw 的权限模型：硬币的两面
OpenClaw 的权限设计本身是合理的，但它的高权限特性放大了任何安全漏洞的破坏力。
OpenClaw 采用的是 OAuth 风格的权限范围（scopes）模型：
| 权限范围 | 含义 |
|---|---|
operator.pairing | 最低级别，用于设备配对 |
operator.invoke | 调用工具执行操作 |
operator.admin | 管理员权限 |
gateway.connect | 连接网关 |
file.read / file.write | 文件读写 |
exec.run | 执行系统命令 |
这些权限组合起来，使 OpenClaw 能够完成复杂的跨系统操作。但问题在于：任何单一权限的泄露，都可能成为攻击链的起点。
以 CVE-2026-33579 为例，攻击者只需要持有 operator.pairing（最低权限），就可以发起一个设备配对请求，然后——自己批准自己的请求。系统没有验证「批准者」的权限级别，导致攻击者可以静默地将自己的权限从 operator.pairing 提升到 operator.admin。整个过程不需要任何用户交互，攻击者从「访客」变成了「系统管理员」，只需要几秒钟。
Blink 的安全研究人员对此的评价一针见血：「'权限提升'这个词还不足以形容这种情况：结果是完全的实例接管。」
1.3 当前防御手段的系统性缺失
ClawKeeper 论文（arXiv:2603.24414v1）中，对当前 OpenClaw 安全生态的防御手段做了系统性梳理，指出了三个核心问题：
问题一：静态规则无法应对动态行为
传统的安全工具（杀毒软件、WAF、IDS）都依赖于预先定义的规则库。这些规则可以检测已知攻击模式（如「包含 SELECT * FROM users 的 SQL 语句」），但无法理解 AI 的动态行为意图。
当 AI 说「我要读取配置文件来理解用户偏好」时，传统的 DLP（数据防泄露）工具无法区分这是正常操作还是数据窃取，因为它不知道「理解用户偏好」是否真的是 AI 的真实意图，还是攻击者通过提示词注入诱导 AI 执行的文件读取。
问题二：「让 AI 自己管自己」的模式存在根本性缺陷
OpenClaw 现有的安全机制高度依赖 AI 自身的判断能力：让 AI 自己评估操作风险、让 AI 自己拒绝可疑指令。但 ClawKeeper 的研究者指出了这一模式的核心问题——运动员不能同时当裁判。
在复杂的真实环境中，AI 的推理能力受限于其上下文窗口大小和 token 预算。当面临精心构造的提示词注入攻击时，AI 很难在有限的推理资源内识别出所有隐藏的恶意意图。更关键的是，AI 本身并没有独立的「安全动机」——它只是执行用户的指令，它没有「保护系统安全」的内在目标。
问题三：缺乏端到端的行为追踪机制
当一个安全事件发生后，安全团队需要回答三个问题：发生了什么？怎么发生的？如何防止再次发生？但 OpenClaw 的现有日志体系难以支撑这种级别的溯源分析——工具调用的参数、执行的上下文、决策的依据，这些信息在标准日志中往往缺失或不完整。
第二章：ClawKeeper 三层防御架构——从设计哲学到工程实现
ClawKeeper 的设计哲学，用一句话概括就是：分层治理、各司其职、独立演进。
它没有试图用一个单一机制来解决所有安全问题，而是将防御能力分布在三个不同的层次，每个层次有不同的职责范围、不同的执行时机、不同的技术实现。这三个层次相互配合、相互监督，形成了一个立体的安全防御网络。
┌─────────────────────────────────────────────┐
│ Watcher-based（监管者层） │
│ 系统级安全中间件，独立的安全 Agent │
│ 关键时刻干预/接管执行流程 │
├─────────────────────────────────────────────┤
│ Plugin-based（插件层） │
│ 内部运行时强制执行器 │
│ 配置加固、主动威胁检测、行为监控 │
├─────────────────────────────────────────────┤
│ Skill-based（技能层） │
│ 指令层安全策略注入 │
│ 结构化安全上下文、强制安全边界限制 │
└─────────────────────────────────────────────┘
2.1 第一层：Skill-based 技能级防护——给 AI 装上「行为准则」
2.1.1 设计思路
Skill-based 防护的核心理念是：在 AI 开始行动之前，就告诉它「什么能做、什么不能做」。
这不是简单的「禁止执行某些命令」列表，而是一套结构化的安全策略体系，通过 OpenClaw 的 Skill 机制注入到 AI 的上下文中，使 AI 在推理阶段就能获得清晰的安全边界约束。
ClawKeeper 的研究者认为，传统的基于规则的安全策略（防火墙规则、访问控制列表）之所以在 AI 场景下效果有限，是因为 AI 并不能像程序代码那样机械地「匹配规则」。AI 需要的是结构化的、可理解的、与推理过程无缝集成的安全上下文。
2.1.2 实现机制
Skill-based 防护通过以下机制实现：
（1）结构化安全上下文注入
ClawKeeper 定义了一套结构化的安全策略 DSL（Domain Specific Language），用于描述安全边界。例如：
# ClawKeeper 安全策略示例
security_context:
allowed_tools:
- file.read
- browser.snapshot
- message.send
explicit_denied:
- exec.run # 除非经过 Watcher 批准
data_classification:
public: [read, send]
internal: [read, write] # 需要记录审计日志
confidential: [read] # 只读且加密传输
file_access_policy:
allowed_paths:
- /home/user/projects
- /tmp/uploads
denied_paths:
- /home/user/.ssh
- /home/user/.aws
- /etc/passwd
max_file_size: 10485760 # 10MB
network_policy:
allowed_domains:
- api.openai.com
- api.github.com
allowed_ports: [80, 443]
dns_filter: true
这套 DSL 的设计原则是：声明式、层级化、可组合。不同的安全策略可以组合使用，AI 在推理时加载这些策略，就像一个经验丰富的工程师收到了一份详细的工作规范——明确知道哪些操作是允许的、哪些是需要特别注意的。
（2）强制执行与降级处理
当 AI 的行为触及安全边界时，Skill-based 层会采取以下策略：
- 警告模式：在 AI 执行高风险操作前，暂停执行并注入额外的安全上下文，要求 AI 重新评估
- 限制模式：对特定类型的操作设置自动降级，例如将「执行任意 shell 命令」降级为「执行预定义的白名单命令」
- 拒绝模式：对明确违反安全策略的操作，直接拒绝并记录审计日志
# Skill-based 层策略执行伪代码示例
class SkillBasedGuard:
def __init__(self, security_policy):
self.policy = security_policy
self.execution_history = []
def before_tool_invocation(self, tool_name, params, context):
# 检查工具是否在白名单中
if tool_name not in self.policy.allowed_tools:
return GuardAction.DENY, f"Tool {tool_name} not in allowed list"
# 检查文件路径是否在允许范围内
if 'path' in params:
path = params['path']
if not self._is_path_allowed(path):
return GuardAction.DENY, f"Path {path} outside allowed scope"
# 检查数据分类合规性
if self._contains_confidential_data(params):
if not self._has_proper_encryption(params):
return GuardAction.WARN, "Confidential data requires encryption"
return GuardAction.ALLOW, None
def _is_path_allowed(self, path):
for allowed in self.policy.allowed_paths:
if path.startswith(allowed):
for denied in self.policy.denied_paths:
if path.startswith(denied):
return False
return True
return False
（3）动态策略更新
传统的安全策略需要管理员手动更新，但 ClawKeeper 的 Skill-based 层支持基于威胁情报的动态更新。当 ClawKeeper 的威胁情报库发现新的攻击模式时，可以自动更新所有已部署实例的安全策略，而无需人工介入。
这一机制解决了传统安全方案的一个核心痛点——策略滞后性。在传统方案中，从发现新威胁到所有用户更新规则，中间往往有数天甚至数周的窗口期。而在 ClawKeeper 中，这个窗口期可以缩短到数小时甚至数分钟。
2.1.3 实际应用场景
Skill-based 层特别适合处理以下场景：
- 提示词注入防御：当 AI 从外部来源（网页、邮件、文档）获取指令时，Skill-based 层可以过滤掉明显异常的指令模式，防止注入的恶意指令被 AI 执行
- 数据分类强化：当 AI 处理包含敏感信息的文件时，自动标记并强制执行相应的访问限制
- 权限最小化执行：根据任务类型动态限制 AI 的可用工具集，例如只读任务只开放读取工具，写入任务需要额外批准
2.2 第二层：Plugin-based 插件级防护——在 AI 的「大脑」里装上实时监控
2.2.1 设计思路
如果说 Skill-based 层是在 AI「思考之前」设置边界，那么 Plugin-based 层就是在 AI「行动之时」进行实时监控。
Plugin-based 防护作为 OpenClaw 的内部运行时强制执行器，运行在 AI 执行链路的关键节点上，能够在工具调用的实际参数被传递之前进行拦截和检测。这是一个主动防御机制——它不仅仅是在 AI「想做坏事」时发出警告，而是在恶意行为真正发生之前就将其阻止。
2.2.2 实现机制
（1）运行时拦截架构
ClawKeeper 的 Plugin-based 层实现为一个 OpenClaw 插件（Plugin），它注册在 OpenClaw 的工具调用链路上：
用户指令 → AI 推理 → 工具调用决策
↓
Plugin-based 拦截器（运行时）
↓
威胁检测 → 行为评估 → 决策执行
↓
允许通过 / 修改参数 / 拒绝执行
↓
工具实际执行
这一架构的关键设计点是：它不修改 AI 的推理过程，只是对 AI 的输出（工具调用请求）进行安全检查。这保证了 AI 的推理能力不受影响，同时在执行层面提供了额外的安全护栏。
（2）主动威胁检测引擎
Plugin-based 层的核心是一个轻量级的威胁检测引擎，它在运行时对工具调用的参数进行多维度分析：
# Plugin-based 层威胁检测引擎核心逻辑
class ThreatDetectionEngine:
def __init__(self):
self.patterns = self._load_malicious_patterns()
self.behavior_analyzer = BehaviorAnalyzer()
self.config_hardener = ConfigHardener()
def analyze_tool_call(self, tool_name, params, execution_context):
threats = []
# 1. 模式匹配：检测已知恶意模式
for pattern in self.patterns:
if pattern.matches(params):
threats.append(Threat(
severity=pattern.severity,
type=pattern.type,
description=pattern.description,
mitigation=pattern.mitigation
))
# 2. 行为分析：检测异常行为模式
behavior_score = self.behavior_analyzer.score(
tool_name, params, execution_context
)
if behavior_score > 0.8: # 高风险行为
threats.append(Threat(
severity=Severity.HIGH,
type="anomalous_behavior",
description=f"行为评分 {behavior_score:.2f} 超过阈值",
mitigation="暂停执行，要求 Watcher 介入"
))
# 3. 参数验证：深度检查参数的合法性和安全性
param_validation = self._validate_params(tool_name, params)
if not param_validation.valid:
threats.append(Threat(
severity=Severity.MEDIUM,
type="invalid_params",
description=param_validation.error,
mitigation="修正参数后重试"
))
return ThreatReport(threats=threats, action=self._decide_action(threats))
def _decide_action(self, threats):
max_severity = max(t.severity for t in threats)
if max_severity >= Severity.CRITICAL:
return Action.BLOCK # 严重威胁，直接阻止
elif max_severity >= Severity.HIGH:
return Action.WATCHER_REVIEW # 高风险，提交给 Watcher
elif max_severity >= Severity.MEDIUM:
return Action.WARN_AND_LOG # 中风险，警告但允许执行
else:
return Action.ALLOW # 低风险，放行
（3）配置加固模块
Plugin-based 层还包含一个配置加固模块，用于自动修复 OpenClaw 的不安全默认配置：
class ConfigHardener:
def apply_security_hardening(self, config):
hardened = config.copy()
# 禁用不安全的默认配置
if not config.get('auth.enabled'):
hardened['auth.enabled'] = True
hardened['auth.method'] = 'token'
# 限制 Gateway 暴露范围
if config.get('gateway.bind') == '0.0.0.0':
hardened['gateway.bind'] = '127.0.0.1' # 仅监听本地
hardened['gateway.tls.enabled'] = True
# 加密敏感配置
sensitive_keys = ['api_key', 'token', 'secret', 'password']
for key in sensitive_keys:
if key in hardened:
hardened[key] = self._encrypt(hardened[key])
# 限制 WebSocket 权限
hardened['websocket.require_auth'] = True
hardened['websocket.token_expiry_seconds'] = 3600
return hardened
def _encrypt(self, value):
# 使用 AES-256-GCM 加密敏感值
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
key = get_hardening_key() # 从安全存储获取密钥
aesgcm = AESGCM(key)
nonce = os.urandom(12)
ciphertext = aesgcm.encrypt(nonce, value.encode(), None)
return f"ENC:{base64.b64encode(nonce + ciphertext).decode()}"
这个配置加固模块的意义重大——它从根源上减少了攻击面。前文提到的 CVE-2026-33579 漏洞，其根本原因之一就是 OpenClaw 的默认配置过于宽松（未启用身份验证、默认绑定 0.0.0.0）。通过在 Plugin 层自动加固配置，ClawKeeper 可以确保每个部署实例都遵循安全基线。
（4）持续行为监控
Plugin-based 层的另一个关键功能是持续的行为监控和异常检测。它不仅在单个操作层面进行检测，还会在时间维度上分析行为序列：
class BehaviorAnalyzer:
def __init__(self):
self.session_profiles = {} # 按会话ID记录行为画像
self.baseline_profiles = self._load_baseline_profiles()
def score(self, tool_name, params, context):
session_id = context.session_id
if session_id not in self.session_profiles:
self.session_profiles[session_id] = SessionProfile()
profile = self.session_profiles[session_id]
# 更新行为画像
profile.record_action(tool_name, params)
# 检测行为漂移
drift_score = self._compute_drift_score(profile, context)
# 检测目标偏移（goal hijacking）
goal_drift = self._compute_goal_drift(profile, context)
# 检测数据外泄模式
exfiltration_risk = self._compute_exfiltration_risk(profile, params)
# 综合评分
return (0.4 * drift_score + 0.4 * goal_drift + 0.2 * exfiltration_risk)
def _compute_goal_drift(self, profile, context):
"""
检测目标偏移攻击（Goal Hijacking）。
攻击者通过提示词注入，将 AI 的执行目标从用户原始意图
悄悄转移到攻击者指定的目标。
"""
original_goal = profile.initial_goal
current_goal = context.inferred_goal
if not original_goal:
return 0.0
# 使用 embedding 相似度计算目标偏移程度
similarity = compute_embedding_similarity(original_goal, current_goal)
# 如果当前目标与原始目标差异过大，可能是目标被劫持
drift = 1.0 - similarity
return min(drift * 2.0, 1.0) # 放大漂移效果，限制最大值为1.0
2.3 第三层：Watcher-based 监管者级防护——最关键的创新
2.3.1 设计思路
Watcher-based 是 ClawKeeper 三层架构中最具创新性的一层，也是整个方案的核心差异化所在。
ClawKeeper 的研究者指出了当前 AI Agent 安全方案的一个根本性缺陷：它们都在试图让 AI「自己管自己」。无论是让 AI 评估自己的行为风险，还是让 AI 遵守内置的安全规则，本质上都是在同一个系统内部寻求安全——而这违背了安全领域的一个基本原则：监管者不能由被监管者自己担任。
Watcher-based 层的解决方案是：引入一个完全独立于 OpenClaw 业务运行的安全 Agent，专门负责监督 OpenClaw 的执行过程。这个安全 Agent 就像企业里的合规部门——它不参与业务运营，但有权随时审查业务行为，并在发现问题时介入或接管执行流程。
2.3.2 架构设计
┌──────────────────────────────────────────────────────────┐
│ OpenClaw 业务系统 │
│ 用户 ←→ AI推理引擎 ←→ 工具调用 ←→ 外部服务/文件系统 │
└──────────────────────┬───────────────────────────────────┘
│ 监督通信（独立通道）
↓
┌──────────────────────────────────────────────────────────┐
│ Watcher 安全中间件 │
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 行为轨迹 │ │ 威胁评估 │ │ 干预决策 │ │
│ │ 记录器 │→ │ 引擎 │→ │ 执行器 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ↑ │
│ ┌──────────────────────────────────────────┐ │
│ │ 记忆池（可自进化） │ │
│ │ 积累威胁模式 → 优化检测策略 → 持续学习 │ │
│ └──────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
关键设计决策：解耦
Watcher 被设计为一个系统级的安全中间件，它与 OpenClaw 的业务逻辑完全解耦：
- 进程解耦：Watcher 运行在独立的进程中，不与 OpenClaw 共享内存空间
- 权限解耦：Watcher 拥有独立的安全 Agent 身份，与被监管的 OpenClaw 实例使用不同的凭据
- 状态解耦：Watcher 维护独立的行为记录和威胁情报库，不依赖 OpenClaw 的内部状态
- 更新解耦：Watcher 的检测策略可以独立于 OpenClaw 的版本进行更新
这种解耦设计保证了即使 OpenClaw 实例本身被攻击者攻陷，Watcher 仍然能够保持独立运作，继续履行监督职责。
2.3.3 自进化能力
Watcher 最有价值的设计之一，是它的记忆池（Memory Pool）和自进化机制：
class WatcherMemoryPool:
"""
Watcher 的记忆池，存储历史威胁模式和检测经验。
关键特性：能够从历史事件中学习，不断优化检测策略。
"""
def __init__(self):
self.threat_patterns = [] # 已确认的威胁模式
self.false_positives = [] # 误报案例（用于降低误报率）
self.detection_rules = {} # 活跃的检测规则
self.session_contexts = {} # 会话级别的上下文
def record_threat(self, threat_event):
"""记录一个真实的威胁事件"""
pattern = self._extract_pattern(threat_event)
if pattern not in self.threat_patterns:
self.threat_patterns.append(pattern)
# 自动生成新的检测规则
new_rule = self._generate_detection_rule(pattern)
self.detection_rules[pattern.id] = new_rule
def record_false_positive(self, event):
"""记录一个误报案例，用于减少未来的误报"""
self.false_positives.append(event)
# 调整相关检测规则的敏感度
self._recalibrate_rules(event)
def _generate_detection_rule(self, pattern):
"""从威胁模式自动生成检测规则"""
return DetectionRule(
id=f"auto_{pattern.id}_{len(self.detection_rules)}",
trigger_conditions=pattern.conditions,
severity=pattern.severity,
confidence_threshold=0.85, # 高置信度才自动触发
auto_action=Action.WATCHER_REVIEW # 中等置信度提交人工审核
)
def get_detection_context(self, session_id, current_action):
"""为当前行动提供历史上下文"""
session_history = self.session_contexts.get(session_id, [])
similar_past_sessions = self._find_similar_sessions(
current_action, session_history
)
return {
"session_history": session_history,
"similar_threats": [s.threat for s in similar_past_sessions],
"applicable_rules": self._get_applicable_rules(current_action),
"threat_intelligence": self._check_threat_intel(current_action)
}
这个记忆池的工作逻辑是：
- 当 Watcher 检测到一个新的威胁模式时，将其记录到记忆池
- 从威胁模式自动生成新的检测规则，加入活跃规则集
- 如果一个检测规则产生了误报，将误报案例记录下来并调整规则敏感度
- 在评估新的行为时，综合考虑当前行为与历史威胁模式的相似度
这意味着 Watcher 是会「长记性」的。传统的安全规则需要人工维护和更新，而 ClawKeeper 的 Watcher 可以从每次安全事件中学习，自动完善自己的检测能力。随着使用时间的增长，Watcher 对特定部署环境的威胁感知会越来越精准。
2.3.4 干预决策与执行
当 Watcher 检测到高风险行为时，它有三种干预方式：
class WatcherInterventionExecutor:
def execute_intervention(self, threat, session_context):
"""
根据威胁级别执行不同的干预措施。
干预策略遵循「最小侵入性」原则：能警告就不阻止，
能暂停就不终止。
"""
if threat.severity == Severity.CRITICAL:
# 最高威胁：立即接管，暂停 AI 操作
return Intervention(
action=InterventionAction.SUSPEND,
message="检测到严重威胁，AI 操作已暂停等待人工审核",
duration=timedelta(hours=1),
notify=['admin', 'security_team']
)
elif threat.severity == Severity.HIGH:
# 高风险：降级执行，要求确认
return Intervention(
action=InterventionAction.DEGRADE,
message="检测到高风险操作，降级为只读模式",
degraded_capabilities=['exec.run', 'file.write'],
require_explicit_approval=True,
notify=['admin']
)
elif threat.severity == Severity.MEDIUM:
# 中风险：增强监控，记录但不阻止
return Intervention(
action=InterventionAction.ENHANCED_MONITORING,
message="已记录可疑行为，继续执行但加强监控",
enhanced_logging=True,
log_retention_days=90,
notify=[]
)
第三章：三层防御的协同机制——1+1+1 > 3
ClawKeeper 的三层防御不是孤立运作的，它们之间存在精心设计的协同机制。
3.1 信息共享与告警链
Skill-based 检测到异常
↓
通知 Plugin-based（更新运行时上下文）
↓
Plugin-based 加强参数验证
↓
如果情况升级 → 通知 Watcher
↓
Watcher 进行深度分析 → 决定干预级别
例如，当 Skill-based 层发现一个 AI 的行为偏离了预定义的安全上下文时：
- Skill-based 在 AI 的上下文中注入警告信息，要求 AI 重新评估
- 同时将这一事件通知 Plugin-based 层，后者对即将执行的工具调用进行更严格的参数验证
- 如果 Plugin-based 在参数中发现了与攻击模式高度匹配的迹象（如文件路径包含
/etc/passwd），则将事件上报给 Watcher - Watcher 对整个会话历史进行深度分析，检测是否存在目标偏移攻击（Goal Hijacking）
- 如果 Watcher 确认是攻击行为，则执行相应的干预措施
3.2 防御纵深：即使一层失效，其他层仍能兜底
ClawKeeper 的三层架构天然实现了防御纵深（Defense in Depth）：
攻击者绕过 Skill-based？
→ Plugin-based 仍在运行时进行检测
攻击者伪造 Plugin-based 检测结果？
→ Watcher 的独立分析会捕获异常
攻击者尝试禁用 Watcher？
→ Watcher 受到独立进程保护，且禁用行为本身会被记录和告警
即使某个层次被攻击者绕过或欺骗，其他层次仍然能够提供保护。这种「纵深防御」的设计思想，借鉴了传统网络安全领域的最佳实践，但在 AI Agent 场景下做了针对性的适配。
3.3 性能开销：如何在安全与效率之间取得平衡？
ClawKeeper 的研究者对其性能开销进行了基准测试：
| 检测层 | 平均延迟增加 | 吞吐量影响 |
|---|---|---|
| Skill-based | < 5ms | < 1% |
| Plugin-based | < 15ms | < 3% |
| Watcher-based | < 50ms | < 5% |
| 三层合计 | < 70ms | < 10% |
整体 < 10% 的吞吐量影响，对于大多数实际应用场景来说是完全可以接受的。相比之下，一次安全事件（数据泄露、系统被入侵）的处理成本通常是正常运营成本的数十倍甚至数百倍——安全投入的 ROI 是正向的。
第四章：部署实践——从安装到企业级配置
4.1 快速上手
ClawKeeper 已在 GitHub 开源，安装过程相对简单：
# 克隆仓库
git clone https://github.com/your-org/clawkeeper.git
cd clawkeeper
# 使用安装脚本（支持 macOS/Linux）
chmod +x scripts/install.sh
./scripts/install.sh
# 或者使用 Docker 部署（推荐生产环境）
docker compose -f docker/docker-compose.yml up -d
安装后，运行初始化向导：
python3 -m clawkeeper setup
向导会引导完成以下配置：
- 安全级别选择：开发环境 / 生产环境 / 企业级高安全环境
- 网络配置：Gateway 绑定地址、是否暴露公网
- 监控配置：日志级别、告警渠道（Webhook / Email / 企业微信）
- 威胁情报：连接 ClawKeeper 官方威胁情报库（可选）
4.2 企业级部署架构
对于需要高安全等级的企业部署，ClawKeeper 推荐以下架构：
┌─────────────────┐
│ 负载均衡器 │
│ (HTTPS终止) │
└────────┬────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ OpenClaw │ │ OpenClaw │ │ OpenClaw │
│ 实例 1 │ │ 实例 2 │ │ 实例 N │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │
└───────────────────┼───────────────────┘
│
┌────────▼────────┐
│ Watcher 集群 │
│ (高可用部署) │
└────────┬────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ SIEM │ │ 告警 │ │ 审计 │
│ 系统 │ │ 系统 │ │ 日志库 │
└─────────────┘ └─────────────┘ └─────────────┘
关键部署要点：
- Watcher 集群化：在生产环境中，Watcher 应以高可用集群模式部署，避免单点故障
- 独立网络通道：Watcher 与 OpenClaw 实例之间的通信应使用独立的网络通道，防止被攻击者干扰
- SIEM 集成：ClawKeeper 支持与主流 SIEM 系统（Splunk、Elastic SIEM）集成，实现统一的安全运营
- 审计日志持久化：所有安全事件日志应持久化存储到独立的审计日志库，满足合规要求
4.3 与 OpenClaw 原生安全的对比
| 维度 | OpenClaw 原生安全 | ClawKeeper |
|---|---|---|
| 防御时机 | 被动（依赖 AI 自身判断） | 主动（三层主动拦截） |
| 权限模型 | OAuth 风格（存在绕过的可能） | 独立监管（不依赖被监管者自身） |
| 威胁情报 | 无 | 支持动态更新 |
| 行为分析 | 无 | 会话级行为画像 + 目标漂移检测 |
| 性能影响 | 无 | < 10% |
| 部署复杂度 | 无需额外安装 | 需要独立部署 |
第五章：从 ClawKeeper 看 AI Agent 安全的新范式
5.1 「用智能体监管智能体」的意义
ClawKeeper 最深刻的意义，不在于它具体解决了哪些安全问题，而在于它提出了一个新的安全范式：在 AI Agent 时代，安全不能依赖于被监管者的「自觉」，必须建立独立、客观、具备强制干预能力的外部监管体系。
这一理念在人类社会中有悠久的传统——三权分立、司法独立、新闻监督——都是基于同样的逻辑：权力需要制衡，监管者不能由被监管者自己担任。ClawKeeper 将这一理念引入了 AI Agent 领域，提出了「安全中间件」这一新的技术形态。
5.2 对整个 AI Agent 安全领域的启示
启示一：安全基础设施需要与 AI 能力同步演进
随着 AI Agent 越来越深入系统核心、掌握越来越多的关键权限，传统的安全工具（防火墙、杀毒软件、WAF）将越来越力不从心。我们需要新一代的「AI-native」安全基础设施，它们从设计之初就考虑了 AI 的动态性、推理能力和行为复杂性。
启示二：开放生态需要标准化安全接口
ClawKeeper 的三层防御架构得以实现，很大程度上得益于 OpenClaw 的 Skill 和 Plugin 扩展机制。但目前整个行业缺乏统一的安全接口标准，不同的 Agent 平台有不同的扩展机制，这导致安全工具难以跨平台复用。
启示三：威胁情报在 AI 安全中扮演关键角色
ClawKeeper 的自进化机制表明，在 AI 安全领域，威胁情报的价值可能比传统安全领域更高。因为 AI 的行为空间几乎是无限的，静态规则无法覆盖所有情况，而基于真实威胁情报的动态规则更新，是应对这一挑战的关键。
5.3 局限性与未来方向
ClawKeeper 目前仍然处于 v1.0 阶段，存在一些局限性：
- 多 Agent 协作场景支持不足：当前版本主要针对单个 OpenClaw 实例，在多 Agent 协作场景下的安全治理还有待完善
- 非英文环境适配：安全策略 DSL 和告警系统主要面向英文用户，中文支持需要加强
- 性能优化空间：在超大规模部署场景下（数千个并发 Agent），三层防御的性能开销可能需要进一步优化
- 与其他安全框架的互操作性：目前 ClawKeeper 与 OPA（Open Policy Agent）、Sigstore 等通用安全框架的集成还在规划中
根据论文和项目 Roadmap，未来的发展方向包括：
- 多 Agent 安全编排：支持在复杂多 Agent 协作场景下的统一安全管理
- 形式化验证：对三层防御架构的核心逻辑进行形式化验证，证明其安全性
- 跨平台安全接口：推动 ClawKeeper 的安全接口成为行业标准
- AI 安全大模型：利用大模型能力，进一步提升威胁检测的准确性和覆盖面
结语
2026 年，AI Agent 正在从「会说话的机器人」进化为「会干活的超级员工」。这一转变带来的安全挑战，不是传统安全工具的升级版可以应对的——它需要全新的安全范式、架构设计和工程实践。
ClawKeeper 的出现，是这个方向上的一次重要探索。它的三层防御架构、自进化能力、以及「用智能体监管智能体」的理念，为整个行业提供了一个有价值的参考。
但更重要的是，它提醒我们：在 AI 越来越强大的时代，安全的优先级应该比以往任何时候都更高。不是因为 AI 会「变坏」，而是因为 AI 越来越深入地嵌入我们的数字生活——它手里的钥匙越来越多，门锁就必须越来越牢固。
ClawKeeper 已经在 GitHub 开源。如果你正在使用 OpenClaw，或者对 AI Agent 安全领域感兴趣，不妨亲自上手试试。毕竟，安全不是纸上谈兵，只有在实际环境中经受检验的安全方案，才是真正可靠的安全方案。
参考资源：
- ClawKeeper GitHub：https://github.com/your-org/clawkeeper
- 论文：arXiv:2603.24414v1
- OpenClaw 安全公告：https://openclaw.io/security
- CVE-2026-33579：https://nvd.nist.gov/vuln/detail/CVE-2026-33579