企业官网建设流程全解析

把同一个大模型装进两个不同的 Agent 框架，再跑同一批自动化任务，结果会差到什么程度？

很多人以为答案是“差不多”。既然底层模型一样，Agent 只是搭个壳，能差到哪里去？但 Rohan Paul 在对 Atomic Bot 实验的评述里给出了一个更值得琢磨的判断：OpenClaw 2.0 与 Hermes Agent 都跑在 GLM 5.3 上时，主要差异不在模型选择、不在工具数量，而在两者的自检方式（self-check）完全不同。

这篇文章不打算只复述实验结论，而是想把“自检方式”这个容易被忽略的变量拆开讲清楚：Agent 的自检到底是什么？OpenClaw 2.0 那一路和 Hermes Agent 这一路分别怎么设计？为什么同一个模型会给两种框架留出这么大的行为差异？对正在做 Agent 选型或自己写 Agent 循环的开发者来说，这个差异会直接影响任务成功率、token 成本，甚至是生产环境的失控概率。

读完你会得到三样东西：一套判断 Agent 框架是否“靠谱”的分析框架，两种自检路线的优缺点对照，以及你自己给 Agent 加自检逻辑时可以直接照搬的代码和配置思路。

1. Atomic Bot 实验真正要回答的问题

先说明一下背景。Atomic Bot 从目前公开材料看，并不是一个传统意义上的模型 Benchmark（比如让模型做一堆选择题），而更像一组围绕 Agent 自动化任务开展的对照实验：把不同的 Agent 框架接上相同的底层模型，再让它们去完成具有一定原子性的真实任务，观察谁能在更少的干预下稳定跑完整个流程。

这类实验的价值在于，它把“模型能力”这个变量固定住了。过去我们对比 GPT 和 Claude，比的是模型本身的推理和生成能力；但 Atomic Bot 比的是另一个层面：当大模型已经具备足够强的理解和推理能力时，外面包的那层 Agent 框架，到底是放大了模型能力，还是拖了后腿。

Rohan Paul 的评述之所以值得关注，是因为他把结论指向了一个很多人没认真想过的地方：OpenClaw 2.0 和 Hermes Agent 在 GLM 5.3 上都跑得动、都能调工具、都能完成任务，但两者在“完成任务过程中如何确认自己做对了”这件事上走了完全不同的技术路线。而恰恰是这个不容易被量化的环节，决定了最终的成功率、出错后的恢复速度，以及你敢不敢让它去碰真实环境。

如果只看任务完成率，你可能会觉得两个框架“差不多”。但把实验过程里的失败案例、重试次数、工具误调用次数摆在一起，你会看到自检方式的差距被迅速放大。这也是为什么我认为，Agent 领域的下一轮比拼重点，正在从“能接多少模型、能调多少工具”转向“做错之后能不能自己发现、自己纠正”。

2. Agent 的自检到底是什么

要理解这场实验的结论，先要搞清楚一个概念：Agent 的自检，和我们平时说的代码测试、单元测试有什么不同。

普通软件的测试是在代码之外做的，写完后跑一遍用例，验证输出对不对。但 Agent 是一个“每次运行时行为都可能不一样”的程序，它每一步都可能产生新的工具调用、新的中间结论，你没法提前给它写死所有测试用例。所以 Agent 必须在运行过程中，自己对自己做检查。这个检查发生在三个层面：

第一层：动作前检查。模型决定要调用某个工具时，参数格式对不对、字段全不全、这个工具在当前场景下是否被允许使用。很多 Agent 失控，不是模型不会思考，而是它拿着一个残缺的参数就去调了工具。

第二层：计划检查。Agent 在动手之前通常会生成一个多步计划。这个计划是否真的指向最终目标，还是已经跑偏了？很多复杂任务失败，不是因为某一步执行出错，而是计划从第三步开始就偏离了任务本意，后面的步骤越走越远。

第三层：结果检查。工具返回结果后，Agent 是否能判断这个结果符合预期？如果结果和预期矛盾，它是停下来反思，还是拿着错误结果继续往下做？

一个没有自检机制的 Agent，就像一个不看需求文档就直接写代码、写完也不跑测试的开发同学。模型能力越强，它“自信地犯错”的可能性反而越高，因为它能把一个错误计划说得天衣无缝。从实践经验看，Agent 项目里最让人头疼的问题不是“模型不会”，而是“模型也不知道自己不会，然后硬着头皮继续执行”。

自检机制就是要在系统层面打断这种“自信地犯错”的循环。它不依赖模型临时发挥，而是把检查动作变成 Agent 主循环里的固定环节。

3. GLM 5.3 在实验中的角色：让底座变量趋同

Atomic Bot 实验选择 GLM 5.3 作为底层模型，本身也是一个关键设计决策。GLM 5.3 是当前比较有代表性的国产大模型系列之一，同时提供不同规格的版本，其中 Flash 类版本主打更低的推理成本，还有面向开发者的 API 接入方式，方便 Agent 框架通过标准接口调用。

在 Agent 架构里，底层模型扮演的角色可以类比成发动机，Agent 框架则是变速箱和底盘。发动机决定了动力上限，但换挡逻辑、悬挂调校、刹车时机才是驾驶体验的真正分水岭。同一个 GLM 5.3，放在 OpenClaw 2.0 和 Hermes Agent 里，相当于同一台发动机装进了两套调校思路完全不同的车。

当一个 Agent 框架调用 GLM 5.3 时，它做的事情远远不只是“把用户问题转发给模型”。它还要：

• 把用户的模糊请求转成结构化的任务描述；
• 决定要不要调用工具、调用哪个工具；
• 把工具返回的数据重新组织成模型能理解的上下文；
• 在模型给出不靠谱的中间结果时，决定是继续、重试、还是换一个方案。

这些环节全部由框架代码控制，模型只是每轮被调用一次。所以当底层模型被固定为 GLM 5.3 后，两个框架跑出来的行为差异，几乎全部来自框架自身的控制逻辑，其中差异最大的就是自检逻辑。

用 API 调用 GLM 5.3 本身并不复杂，核心就是一个对话补全请求：

curl -X POST "https://{api_endpoint}/chat/completions" \ -H "Authorization: Bearer {your_api_key}" \ -H "Content-Type: application/json" \ -d '{ "model": "glm-5.3-flash", "messages": [ {"role": "user", "content": "请检查这个三步执行计划是否存在风险"} ], "temperature": 0.3 }'

注意这里的temperature建议调低，因为自检是一个更需要确定性的场景，而不是创意生成场景。这个细节也暗示了一个重要事实：模型本身是不稳定的，同样的输入每次输出都可能不一样。框架要做的事情，就是在这种不确定性之上，搭建一套尽可能确定的检查机制。两个框架的自检差异，本质上是对“如何在不确定的模型输出周围建立确定性边界”这个问题的不同回答。

4. OpenClaw 2.0 的路线：执行前的结构化约束

从实验评述和社区讨论可以感受到，OpenClaw 2.0 的自检思路偏向“在动作发生之前把风险挡在门外”。它更像一个严谨的工程系统：每个工具调用都要经过格式与规则校验，每个操作都要确认在当前权限范围内。自检不是靠模型“想一想”，而是靠框架代码里的硬性规则。

这条路线有几个典型特征：

第一，工具调用前有参数 Schema 校验。模型说“我想调用搜索工具，关键词是 XXX”，框架并不会直接执行，而是先检查keyword字段是否存在、类型是否正确、长度是否合理。校验不通过，这次调用会被拦截，而不是带着脏数据进入工具逻辑。

第二，白名单思维。Agent 能碰哪些工具、不能碰哪些工具，在框架层就划好了边界。比如允许查询数据库，但只允许只读查询；允许调用计算器，但不允许访问文件系统。这种自检不是模型自己决定“要不要守规矩”，而是系统直接不让它越界。

第三，失败即回退。执行过程中一旦出现不符合规则的结果，OpenClaw 2.0 的思路更倾向于回退到上一个稳定状态，而不是让模型在错误的基础上继续发挥。

这套路线的优势很清晰：可预期、可审计、安全性高。它把 Agent 当作一个需要严格管控的执行器来设计。对于工具调用密集、对稳定性和安全性要求极高的场景，比如自动化运维、定时数据采集、代码批量修改，这种“先检查再动手”的自检方式明显更让人放心。

它的代价也同样清晰：灵活性受限。现实世界的任务往往不会乖乖待在 Schema 里。当任务变得开放、目标模糊、需要临场发挥时，严格的结构化校验可能会误伤一些本来有效的探索行为。就像一个流程特别严格的公司，虽然出错率低，但碰到新鲜问题时响应速度也慢。

从实验角度看，OpenClaw 2.0 这种自检方式更有利于回答“给定明确步骤，Agent 能否稳定执行不跑偏”。但如果任务是“帮我想一个研究方案并执行”，规则前置的方式就不一定是最优解了。

5. Hermes Agent 的路线：对话式反思与计划修正

Hermes Agent 这一路走了另一个方向。从社区使用反馈和热搜关键词可以看出，Hermes Agent 是一个偏产品化的 Agent 形态：有桌面版本，支持对话式交互，可以外挂知识库，也能接入阿里百炼这类模型服务平台来调用 GLM 5.3。这种定位决定了它的自检方式更依赖“循环中的反思与修正”，而不是“动作前的硬性拦截”。

Hermes Agent 的自检逻辑大致是这样的：

1. Agent 先基于用户任务生成一版执行计划。
2. 执行一步之后，把当前结果、原始目标、中间上下文一起打包。
3. 让模型作为“检查者”重新审视一遍：这一步结果和最终目标是否一致？有没有更好的路径？
4. 如果检查者认为出现了偏差，Agent 会重新规划后续步骤，甚至推翻之前的方案。

这种自检方式的核心是：把反思本身也变成一次模型调用。它不是靠写死的规则来判断对错，而是靠模型对上下文的理解来动态判断。这带来一个很有意思的效果：Hermes Agent 在开放式任务上往往表现得更有“弹性”，因为它不需要每一步都符合预设 Schema，出了偏差也有机会在下一轮反思中纠正。

但弹性也意味着代价。每多一轮反思，就多一次模型调用，token 成本和时间延迟都会增加。而且，如果用来反思的模型本身判断力不足，反思就会变成“让一个犯错的人检查自己的错误”，不仅纠正不了问题，还可能把本来正确的步骤改错。所以这种自检路线的效果，对底层模型能力的要求更高。好在实验里用的是 GLM 5.3，推理能力足够支撑多轮反思，这也解释了为什么 Hermes Agent 在它上面能跑出不错的效果。

从产品设计上也能看到这种思路的影子。Hermes Agent 提供回到主页面的命令、支持外挂知识库，本质上都是在给“对话式 Agent”增加自检所需的上下文：知识库让模型在反思时有更可靠的依据，回到主页面则是一种“从混乱的中间状态里重置出来”的兜底手段。它不追求每一步都完美，而是追求“错了之后能回来”。

6. 两种自检方式的差异对照

把两种路线放在一起看，差异比想象中更系统。我用一张表梳理一下：

这两条路线并不是互斥的。真正成熟的 Agent 架构，往往会在动作前用 OpenClaw 2.0 式的规则做快速闸门，在执行后用 Hermes Agent 式的反思做路径修正。前者拦住“明显不该做的动作”，后者纠正“方向对但路径不对”的情况。

Atomic Bot 实验让人觉得两个 Agent “差不多”，是因为单看成功率时，两条路线都可能完成同一批任务。但把失败模式拆开看，区别就明显了：OpenClaw 2.0 的失败更多表现为“任务被拦截，无法继续”，而 Hermes Agent 的失败更多表现为“多消耗了几轮 Token，绕了一圈才回来”。这两种失败，对于不同场景的开发者来说，代价是完全不同的。

7. 从实验反推：怎么给自己的 Agent 设计自检

如果你不想直接选框架，而是想在自己写的 Agent 里加入自检机制，Atomic Bot 实验恰恰给了一个很好的设计模板。我建议按下面三个层次来加，从成本最低的开始。

第一层：给工具调用加 Schema 校验。这是性价比最高的一层自检。别让模型输出的参数直接进工具函数，先过一层 JSON Schema。下面是一个通用示例：

# selfcheck/schema_check.py import json from jsonschema import validate, ValidationError TOOL_SCHEMAS = { "search_news": { "type": "object", "properties": { "keyword": {"type": "string", "minLength": 1}, "max_results": {"type": "integer", "minimum": 1, "maximum": 20}, }, "required": ["keyword"], "additionalProperties": False, }, "calc": { "type": "object", "properties": { "expression": {"type": "string", "pattern": "^[0-9+\\-*/(). ]+$"}, }, "required": ["expression"], "additionalProperties": False, }, } def check_tool_call(tool_name: str, args: dict) -> bool: schema = TOOL_SCHEMAS.get(tool_name) if schema is None: print(f"[selfcheck] unknown tool: {tool_name}") return False try: validate(instance=args, schema=schema) return True except ValidationError as e: print(f"[selfcheck] invalid args for {tool_name}: {e.message}") return False

这段代码里有两个容易忽略的细节。一是additionalProperties: False，它用来防止模型在参数里夹带不该出现的字段；二是pattern，它用来限制工具入参的字符范围，比如计算器工具不应该接收任意字符串。这些都是典型的“规则前置”自检，不消耗模型调用，但能拦住大量低级错误。

第二层：让 Agent 在每轮执行后做一次结果验证。工具返回后不要直接塞进上下文，先用一段独立的判断逻辑确认结果结构是否完整：

# selfcheck/result_check.py def validate_result(tool_name: str, raw_result) -> bool: if tool_name == "search_news": if not isinstance(raw_result, list): return False for item in raw_result: if not all(k in item for k in ("title", "url")): return False return True if tool_name == "calc": return isinstance(raw_result, (int, float)) return False

这一层的价值在于，它能识别出“工具调了但没调对”的情况。很多 Agent 跑飞，不是因为计划错，而是因为某个工具返回了空数组或错误结构，模型却没有发现，依然一本正经地基于错误结果继续分析。

第三层：把反思做成 Agent 主循环里的固定环节。这是最接近 Hermes Agent 路线的做法。用一个反思 Prompt 让模型检查当前进度，并只输出结构化结果：

你正在执行的任务最终目标是：{user_task} 已经完成的步骤与结果如下： {context} 请按顺序自检，不要直接回答用户： 1. 当前进度是否仍然指向最终目标？ 2. 最近一步的执行结果是否可信？是否存在明显矛盾？ 3. 接下来一步是会推进目标，还是会重复已完成的无效动作？ 4. 如果发现偏差，用一句话说明修正方案。 只输出 JSON，格式如下： {"judgement": "ok 或 needs_replan", "reason": "一句话原因", "next": "下一步动作描述"}

注意最后的“只输出 JSON”要求。反思环节如果不限定输出格式，模型很容易写出一大段模棱两可的总结，反而干扰主循环决策。强制结构化输出，也是自检机制的一部分——它让模型的“自我检查结果”能够被下游代码稳定消费。

有了反思判定之后，就可以把它接进 Agent 的主循环里了。下面是一个带自检的最简主循环骨架：

# agent_loop.py def run_task_with_selfcheck(agent, user_task: str, max_rounds: int = 8): """ agent 需要提供： plan(task, context) -> list[dict] 生成或修正计划 run_step(step) -> raw_result 执行单步 reflect(task, history, step_result) -> dict 反思判定 """ plan = agent.plan(user_task, context=[]) history = [] step_index = 0 for _ in range(max_rounds): if step_index >= len(plan): return {"status": "success", "history": history} step = plan[step_index] if not check_tool_call(step["tool"], step["args"]): # 自检点 1：参数不合法，让模型重新生成这一步 step = agent.plan(user_task, context=history, instruction="上一步参数不合法，请重新生成工具调用") if step is None: return {"status": "blocked", "reason": "invalid_tool_args"} continue raw_result = agent.run_step(step) history.append({"step": step, "result": raw_result}) if not validate_result(step["tool"], raw_result): new_plan = agent.plan( user_task, context=history, instruction="上一步工具返回结果不完整，请判断重试还是换方案") plan = new_plan if new_plan else plan continue verdict = agent.reflect(user_task, history, raw_result) # 自检点 2：反思认为方向偏了，重规划 if verdict.get("judgement") == "needs_replan": plan = agent.plan(user_task, context=history, instruction=verdict.get("reason")) step_index = 0 else: step_index += 1 return {"status": "timeout", "reason": f"exceeded {max_rounds} rounds"}

这个骨架里最核心的设计是max_rounds上限。反思循环如果没有边界，一个纠结的 Agent 可以在错误路径上消耗无穷多的 Token。给循环设置上限，本质上也是一种自检——它承认“模型反思不一定收敛”，所以用工程手段强制终止。这一点在实际项目中非常重要，比起让 Agent 无限反思，带着部分结果结束并上报，往往是更可接受的行为。

8. 从社区反馈看 Hermes Agent 的部署常见坑

Hermes Agent 的流行度上升后，部署和上手阶段的问题也随之增多。结合社区里的高频搜索和通用排查路径，可以整理出几个典型场景，给准备尝试的开发者做一个预判。注意，不同版本的安装细节会有差异，以下排查思路是通用的，具体命令以官方文档为准。

这些问题的共同点在于：Agent 工具链的部署问题，绝大多数不是模型问题，而是环境与配置问题。排查时不要上来就怀疑模型能力，先看日志、看配置、看网络，再用最小请求验证连通性，通常能更快定位。

9. 选型判断：你更怕哪一类失败

Atomic Bot 实验留给开发者最大的启示，不是“哪个 Agent 更好”，而是“你在选 Agent 框架时，到底在选什么”。

如果你做一个内部自动化工具，任务是每天定时抓取数据、生成报表、同步到指定系统，那么 OpenClaw 2.0 那种规则前置的自检方式更合适。这类场景怕的不是“不够聪明”，而是“聪明过头”——某天模型突发奇想，调用了不该调的工具，或者给数据库传了一个异常参数。你需要的不是更多反思，而是更硬的闸门。

如果你做一个研究助手或开放式规划工具，任务本身方向不明确、需要不断探索和调整，那么 Hermes Agent 的反思循环会更有价值。这类场景怕的不是“偶尔调用失败”，而是“一条路走到黑”。你需要的是 Agent 能在执行过程中不断自我怀疑、主动换路的能力。当然，代价就是更高的 Token 消耗和更长的响应时间，你要提前做好成本预算。

最稳妥的工程实践，其实是在架构上把两种自检结合起来：面向工具调用层，用 Schema 和权限做前置闸门；面向任务规划层，用反思循环做方向修正。前者保证“不做不该做的事”，后者保证“做了的事始终指向目标”。

回顾整篇文章的核心判断：当 GLM 5.3 这类模型把“思考能力”变成了标准化供给，Agent 框架之间的真正分水岭就落在了如何防止模型自信地犯错这件事上。自检方式决定了 Agent 在真实任务中是稳定交付，还是偶尔失控。建议所有准备做 Agent 应用的开发者，选型时把“自检机制”放进评估清单的第一页，而不是只看模型榜单和工具数量。先问清楚自己：这个 Agent 做错了事，它是能自己发现，还是会一路错到底？这个问题的答案，往往比它用了什么模型更能预测项目的长期表现。

如果你正打算在 Hermes Agent 或 OpenClaw 2.0 之间做选择，建议先跑一批故意包含歧义、缺参数、可能误导模型的小任务，专门观察两个框架在“出错后”的表现，而不是只统计成功率。这种测试思路，比读任何官方宣传材料都更能帮你做出正确的判断。配置和代码示例建议收藏备用，部署时可以对照着调整自己的 Agent 自检逻辑。