使用Fable 5构建Agentic OS：建造者指南

av1dlive 发布于 2026-07-08 阅读 17

本文是 Claude Fable 5 的完整技术指南，教你如何构建一个自动化工作系统，让模型像 100 倍效率的工程师一样工作。系统包含八个构建模块：CLAUDE.md 宪法、确定性门控、心跳循环、信任账本、持续目标验证、预算控制、可选增强循环和运维。核心原则是：法则而非建议、无人自评作业、已完成的工作持续复审。通过 30 天信任排程，系统从监督阶段逐步过渡到自主运行，实现无人值守的代码修复、目标验证和成本管控。文章提供了详细的脚本、配置文件和操作步骤，适合有代码仓库和终端的技术人员。

![图像](https://img.learnblockchain.cn/2026/07/11/x-HMjfAVdawAAbny7.jpg)

这是对 Claude Fable 5 的完整 A-Z 解析：它是什么，以及如何像 100 倍工程师一样使用它

这将彻底改变你与 Claude 合作的方式

在忘记之前，请收藏这 8 个构建

### 简介

你已经拥有了迄今为止最强大的通用模型，却仍在一次一个地输入提示。本指南将改变这一点。

以下是截至 2026 年 7 月的情况。Fable 5 可以无人值守运行数小时，分派自己的子代理，并在一个晚上完成一周的工作。它也是按量计费的（使用积分，$10/M 输入，$50/M 输出），当范围未限定时会过度交付，并且它为错误辩护的说服力甚至超过了大多数人为正确答案辩护的能力。

如果随意使用，它是一种生成令人印象深刻但错误内容的昂贵方式。如果放在系统中使用，它最接近于以每天三美元的价格租用一个员工。

本指南构建了那个系统。不是理念：是实际的文件，按顺序排列，每个文件之后都有一个检查点，这样你在堆叠下一个部件之前就知道它能工作。

你最终将拥有的东西：

一个模型无法协商的 CLAUDE.md（构建 1）

一个每日循环，其中 Fable 5 做出所有决策但几乎不产生 token，便宜的模型做实际工作，独立的验证者评分，一个 bash 脚本持有最终投票（构建 2-3）

一个信任账本，根据测量的通过率自动按技能授予和撤销自主权（构建 4）

一个目标目录，你完成的所有内容每天都持续被重新验证，永不过时，因此没有东西会无声地腐烂（构建 5）

一个自我执行而非让你惊讶的预算（构建 6）

四个可选循环（共识、棘轮、对练、复盘），每个都附带告诉你何时安装它们的条件（构建 7）

一个 cron 计划表，针对系统可能触发的每个警报的运行手册，以及一个 30 天的信任时间表，使其从受监督变为自我扩展。

这是为谁准备的：任何拥有代码库、终端以及 Claude Code 订阅或 API 密钥的人。示例带有代码风格，因为循环是在代码库周围发展起来的，但目标系统和一半的循环同样适用于发票、报告和阅读清单；谓词只是 shell 命令。

如何阅读：按顺序进行，执行检查。构建 0 是官方的 Anthropic 设置和提示语言；之后的一切都是构建在其上的系统。每个构建需要 10 到 20 分钟。最后的 30 天不是阅读时间；它们是渐进信任时间表，在此期间系统赢得无需你运行的权利。总动手时间：大约 2 小时。

支撑一切的三条原则，以便你在阅读之前就能预测任何设计决策：

法律，而非技巧。每条规则都有一个编号、一个“永不”、或一个检查它的命令。任何更模糊的东西都会被优化掉。

没有人给自己的作业评分。规划者、执行者、验证者和门禁是四个不同的角色，最后一个角色是确定性的。

没有东西通过后就不再被关注。已完成的工作升级为持续重新验证的恒等式。一个你只验证一次的目标就是一个带有时间戳的假设。

从这开始不再有长篇大论。八个构建，每个都附带文件、命令和一个检查点。

前置条件

```bash
claude CLI（Claude Code）且拥有 Fable 5 访问权限     # 启用使用积分，设置 /usage-credits cap
llm CLI + OpenRouter 密钥                             # llm install llm-openrouter
jq, gh, git, make, cron
一个包含测试命令的代码库
```

你正在构建的内容

```markdown
your-repo/
  CLAUDE.md                    # 构建 1：宪法
  loop/
    loop.sh                    # 构建 3：心跳
    conductor.md               # 构建 3：路由提示
    triage.md                  # 构建 3：廉价读取器提示
    contract.md                # 构建 2：三个列表
    workers/implement.md       # 构建 3
    workers/verify.md          # 构建 3
    guardrails/verify.sh       # 构建 2：确定性门禁
    scripts/trust-log.sh       # 构建 4
    scripts/log-cost.sh        # 构建 6
    scripts/cost-check.sh      # 构建 6
    quorum.sh                  # 构建 7（可选）
    verify-goals.sh            # 构建 5
    goals/                     # 构建 5：常设目标
    skills/                    # 构建 4：每个员工一个文件
    memory/
      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
  Makefile                     # 构建 8：tick / queue / trust / audit / dream
```

### 构建 0：配置引擎（来自官方 Fable 5 文档）

此构建中的所有内容均来自 Anthropic 自己的文档。在编写你自己的任何文件之前，先设置好这些。

规范表：

| 设置 | 值 | 来源 |
| --- | --- | --- |
| 模型字符串 | claude-fable-5 | 模型概述 |
| 上下文 / 输出 | 1M token / 每次请求最多 128k 输出 | 介绍文档 |
| 价格 | $10/M 输入，$50/M 输出 | 介绍文档 |
| 思考 | 自适应，始终开启；thinking: {type:"disabled"} 被拒绝；思考输出仅总结 | 介绍 + 努力文档 |
| 努力程度 | low、medium、high、xhigh、max；high = 默认 = 省略参数 | 努力文档 |
| API 形状 | output_config: {"effort": "..."} 在 Messages API 上 | 努力文档 |

五个改变构建方式的官方事实：

max_tokens 是思考加上响应文本的硬限制。在 high 和 xhigh 下，设置一个较大的值（从 64k 开始），否则 Fable 会在思考中途空间不足。适用于本指南中的每次 `claude -p` 调用。

xhigh 官方用于“长时间运行的自主任务（超过 30 分钟），token 预算达到数百万”。这是指挥者的位置，本系统中没有其他位置。文档还提到在 Fable 5 上降低努力程度“通常超过先前模型上的 xhigh 性能”，因此抵制升级执行者。

拒绝是 HTTP 200。Fable 5 运行安全分类器（攻击性网络、生物学/生命科学、推理提取）。被拒绝的请求以 `stop_reason: "refusal"` 作为 SUCCESS 响应返回。你的脚本必须检查停止原因，而不是退出码。官方补救措施：配置服务器端回退或 SDK 中间件，以重新路由到 Opus 4.8。

永远不要要求 Fable 回显其推理。提示或技能中出现“展示你的思考”或“在响应中解释你的推理”会触发 `reasoning_extraction` 拒绝类别，并触发回退。迁移时审计每个旧技能。改为阅读结构化思考块。

回合按设计是很长的。在更高的努力程度下，困难任务每次请求需要几分钟；自主运行会延长到数小时。调整客户端超时，并异步检查运行（计划任务，而非阻塞等待）。这就是为什么心跳是 cron 而非阻塞循环。

官方提示包。Anthropic 发布了针对 Fable 5 已知行为的经过测试的提示语言。这些直接放入你的提示中；不要将它们压缩得更薄：

反过度规划（用于指挥者和任何交互式会话）：

```markdown
当你拥有足够的信息可以行动时，就行动。不要重新推导对话中已经确定的事实，
不要重新争论用户已经做出的决定，也不要叙述你不会追求的选择。
如果你在权衡选择，给出推荐，而不是详尽调查。
```

2. 反过度工程（用于每个执行者提示；这是官方防止过度交付的围栏）：

```markdown
不要添加功能、重构或引入超出任务要求的抽象。修复 bug 不需要周围的清理工作。
不要为假设的未来需求进行设计：做最简单且有效的事情。
不要为不可能发生的场景添加错误处理或验证。仅在系统边界进行验证。
```

3. 基于证据的进度声明（用于任何长时间运行；在 Anthropic 的测试中，这几乎消除了虚构的状态报告）：

```markdown
在报告进度之前，对照本次会话中的工具结果审计每个声明。
只报告你能指出证据的工作；如果某件事尚未验证，请明确说明。
如果测试失败，请连同输出一起说明；如果某个步骤被跳过，请说明。
```

4. 自主管道提醒（用于每个 cron 驱动的提示；消除“我现在将运行 X”的提前停止）：

```markdown
你是自主运行的。用户没有在观看，也无法在任务中回答问题。
对于源于原始请求的可逆操作，继续进行，无需询问。
在结束你的回合之前，检查你的最后一段：如果它是一个计划、一个问题或一个关于你尚未完成的工作的承诺，
立即使用工具调用完成该工作。只有当任务完成或你被输入阻挡（只有用户才能提供）时才结束。
```

5. 官方内存格式（用于梦想者和 memory/learnings/）：

```markdown
每个文件存储一课，顶部有一行总结。记录修正和已确认的方法，
包括它们为何重要。不要保存仓库已经记录的内容；
更新现有笔记而不是重复；删除后来证明是错误的笔记。
```

6. 官方验证者指令（文档直接指出：“独立的、全新上下文的验证者子代理通常优于自我批评”）：

```markdown
建立一种方法，每隔 [X] 检查自己的工作情况。
每隔 [X 间隔] 运行一次，使用子代理根据规范验证你的工作。
```

两个值得遵守的脚手架顺序来自文档：从你难度范围的顶部开始（仅在简单工作负载上测试 Fable 会低估它；给它最难解决且未解决的任务，让它确定范围），以及重构旧技能（为先前模型编写的指令通常对 Fable 5 过于规定性，并会降低输出质量；如果默认性能在没有指令的情况下更好，则删除该指令）。

检查 0：你脚本中的每个 `claude -p` 调用在支持的地方都有一个明确的较大的 max_tokens；你的脚本检查 `stop_reason: "refusal"`；任何提示或技能中都没有“展示你的思考”。

### 构建 1：宪法（CLAUDE.md）

为什么，用一句话概括：Fable 遵循法律并围绕技巧进行优化，因此每一行都需要一个编号、一个“永不”、或者一个检查它的命令。

文件规则：四个区块，少于 150 行，没有“一步步思考”（推理始终开启；那些是付费 token），没有预定义的代理角色（Fable 设计比你预定义更好的团队），主要是停止标志。

创建 CLAUDE.md：

```markdown
## CLAUDE.md

### 永不（法律；例外需要先询问）
- 未经询问，一次提交中不得超过 200 行更改。
- 未经监督，不得触碰 src/auth/、src/billing/、migrations/ 或生产配置。
- 不得自行评估工作已完成。完成 = 检查通过。
- 不得发明秘密、端点或约定。停止并询问。
- 不得添加依赖项。在 STATE.md 中提议并停止。
- 在循环内永远不要超过 effort high。xhigh 仅用于一次性审查。
- 不得编辑或删除测试以使其通过。那总是失败。
- 不得在响应文本中回显、转录或解释你的内部推理。
  （官方：会在 Fable 5 上触发 reasoning_extraction 拒绝。）
- 当 /goal 条件通过时，在报告成功之前，将条件作为其谓词写入 goals/<name>.md。

### 调度（路由每个任务；第一个匹配获胜；记录到 memory/dispatch.tsv）
| 模型           | 边际 | 消耗 | 智能 | 品味 |
|-----------------|----------|----------|--------------|-------|
| claude-fable-5  | 2（积分） | 3     | 10           | 10    |
| claude-opus-4-8 | 7（订阅）| 6        | 8            | 9     |
| claude-sonnet-5 | 9（订阅）| 8        | 7            | 7     |
| codex（第二订阅）| 9        | 10       | 9            | 5     |
1. 决策（计划/审查/路由/僵局）-> fable-5，effort high，只读。
2. 读取量 >50k token（日志/PDF/截图）-> codex。永远不要用 fable。
3. 发送给用户（UI/API/文案）-> 品味 >= 8 获得最终审阅。
4. 规范完整 -> sonnet-5，effort medium。
5. 其他情况 sonnet-5；失败时直接升级一级，无需询问。

### 词汇
- “智能” = 难度最高的、无监督处理的问题
- “品味” = UI/UX、代码质量、API 设计、文案
- “完成” = 谓词通过；其他都不算
- “小” = 少于 50 行更改；“快速” = 占用你少于 10 分钟
- “清理” = 行为完全相同，verify.sh 在前后都为绿色

### 完成
- 每个任务在开始工作之前都有一个机器可检查的 done_when。
- 一个既未看到计划也未看到草稿的全新上下文代理将根据该条件进行验证。
- guardrails/verify.sh 拥有最终投票。
- 偏离：保守选项，记录到 IMPLEMENTATION.md，继续。
- 制造者和检查者两次不一致 -> 停止，排队等待人类处理。
```

将数字和路径编辑为你自己的。工作流程特定的材料（PR 流程、发布检查清单）放在 skills/ 中，而不是这里。

检查 1：对于每一行，询问：模型能否以 80% 的合规度声称成功？如果是，则用数字或“永不”重写。`wc -l CLAUDE.md` 少于 150。

### 构建 2：围墙和门禁

为什么：在第一次心跳之前必须声明爆炸半径，并且一个 bash 脚本必须持有最终投票。

创建 loop/contract.md：

```markdown
### 可独立行动
在分支上起草 PR；修复 lint/测试债务；更新 STATE.md；标记 issue

### 需排队等待我
认证、支付、迁移；任何低于“自动”级别的技能；任何超过 400 行的差异

### 会唤醒我
同一项目验证失败两次
网关路由器在运行中交换了模型
每日预算超支
任何请求秘密的操作
某个常设目标被违反
```

创建 loop/guardrails/verify.sh（根据你的技术栈编辑）：

```bash
##!/usr/bin/env bash
set -e
npm run typecheck --if-present
npm test --if-present
npm run lint --if-present
```

检查 2：`./loop/guardrails/verify.sh` 运行并在你当前仓库中退出 0。如果现在失败，先修复它；整个系统依赖于这个脚本。

### 构建 3：心跳

为什么，用三行话：Fable 作为执行者是一张高额账单（500k-1M token 会话，$50/M 输出）；Fable 作为指挥者发出 10-20% 的 token，同时做出 100% 的决策。一个 $0.01 的模型来读取安静的心跳。代理通过 JSON 模式进行交接，因此任何模型都能适应任何位置。

创建 loop/triage.md：

```markdown
你接收最近的提交、开放的 Issue 和 CI 运行。仅输出发现：
- finding: <一行>
  evidence: <commit/issue/run id>
  status: actionable | informational
没有修复，没有意见。无内容可报告 = 输出确切的 "status: quiet"。
任何涉及认证、支付、迁移、秘密的内容 = 始终 actionable，标注 "contract-sensitive"。
```

创建 loop/conductor.md：

```markdown
你是指挥者。你不编写代码。你不编辑文件。
1. 阅读 STATE、信任账本、以下合同。不要依赖它们在你记忆中的版本。
2. 挑选唯一的一个最高价值的可操作项目。
   contract-sensitive、模糊或可能 >400 行差异 -> action: queue
   没有值得做的事情 -> action: stop
3. 否则 action: execute，并附带一个普通模型也能遵循的规范。
仅输出此 JSON：
{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case，
跨运行稳定>", "spec": "...", "done_when": ["<可验证的>", ...] }
你是昂贵的。请简短。你的输出是一个决策，不是一篇论文。
```

创建 loop/workers/implement.md：

```markdown
你接收一个工作订单（JSON）。精确执行规范。
仅向 done_when 执行下一步。小的差异获胜。
缺少凭据或未记录的决策 -> 停止，将问题写入 IMPLEMENTATION.md。永远不要发明秘密或约定。
在 IMPLEMENTATION.md 中记录你做了什么以及为什么（最多 3 行）。
```

创建 loop/workers/verify.md：

```markdown
你接收一个规范和一个差异，仅此而已。仅判定你眼前的内容。
1. 差异是否满足每个 done_when？引用行号。
2. 规范范围之外的任何内容？立刻失败。删除或跳过测试？立刻失败。
仅输出一行： "PASS: <原因>" 或 "FAIL: <原因>"。
制造者曾充满信心。但那不是证据。
```

创建 loop/loop.sh：

```shell
##!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")"
MAX_ITERS="${MAX_ITERS:-10}"
DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"

./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3

for ((i=1; i<=MAX_ITERS; i++)); do
  # 1 分流：安静心跳门，~$0.01
  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
    gh run list --limit 10 2>/dev/null || true; } \
    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
  ./scripts/log-cost.sh triage 0.01
  grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }

# 2 指挥：Fable，xhigh，全新上下文，只读，JSON 输出
  claude -p "$(cat conductor.md)
STATE: $(cat memory/STATE.md)
TRUST: $(./scripts/trust-log.sh --render)
CONTRACT: $(cat contract.md)" \
    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
    --output-format json > /tmp/c.json
  ./scripts/log-cost.sh conductor 0.35

# 2a 路由容差：永远不要迭代你未选择的模型输出
  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
  [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }

jq -r '.result' /tmp/c.json > work-order.json
  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
  [[ "$ACTION" == stop  ]] && exit 0
  [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }

# 3 执行：廉价执行者，隔离工作树
  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
  ./scripts/log-cost.sh worker 0.10

# 4 验证：全新 Fable，无工具，仅看到规范 + 差异
  V=$(claude -p "$(cat workers/verify.md)
SPEC: $(jq -r .spec work-order.json)
DIFF: $(cd "$WT" && git diff)" \
    --model claude-fable-5 --effort high --allowedTools "" \
    --output-format json | jq -r .result)
  ./scripts/log-cost.sh verifier 0.40

# 5 门禁：确定性；然后账本；仅自动级别时推送
  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
    ./scripts/trust-log.sh "$SKILL" pass
    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
      echo "- shipped: $SKILL" >> memory/STATE.md
    else
      echo "- review: $SKILL in $WT" >> memory/STATE.md
    fi
  else
    ./scripts/trust-log.sh "$SKILL" fail
    echo "- FAILED: $SKILL in $WT" >> memory/STATE.md
  fi
  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
done
exit 1   # 迭代上限但未停止：检查 STATE.md
```

退出映射：0 安静/完成，1 上限，2 重新路由，3 预算。全部有标签，故意为之。

检查 3：`chmod +x loop.sh guardrails/verify.sh` 然后手动运行一次 `./loop.sh`。确认：一个安静的仓库以大约一分钱退出 0；一个有可操作事项的仓库生成包含所有五个字段的 work-order.json 以及在 STATE.md 中的裁决行。

### 构建 4：信任账本

为什么：“随着信任增长提高自主权”不是一个机制；一个带有级别规则的 TSV 文件才是。自主权是按技能，而不是按循环。

创建 loop/scripts/trust-log.sh：

```shell
##!/usr/bin/env bash
## 用法：trust-log.sh <技能> <pass|fail> | --render | --tier <技能>
set -euo pipefail
F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
  rate=(r>0)?p/r:0
  if (r>=20 && rate>=0.95) print "auto"
  else if (r<10 || rate<0.90) print "watch"
  else print "queue"}'; }
case "${1:-}" in
  --render)
    printf "%-20s %5s %5s %6s %s\n" skill runs pass rate tier
    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
        "$(tier_of "$r" "$p")"; done < "$F";;
  --tier)
    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
    tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;
  *)
    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
    if [ "$2" = fail ]; then
      runs=$(grep -P "^${1}\t" "$F" | cut -f2)
      [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \
        && echo "ALERT: $1 demoted to watch after $runs runs" >&2 || true
    fi;;
esac
```

级别规则：auto = 20+ 次运行且 95%+ 通过率，无需监督即可推送。queue = 已验证的草稿等待你。watch = 少于 10 次运行或低于 90%，仅草稿。降级是自动的并输出到 stderr，cron 会将其邮件发送给你。

初始化名册：为每个重复性杂务创建 loop/skills/<name>/SKILL.md（fix-lint-debt、fix-flaky-test、bump-deps、triage-issues 是标准的四个）。每个文件：前置元数据（名称、描述、何时）、步骤、一个“永不”列表、一个可验证的 done-when。每个技能从 watch 开始。

检查 4：运行 `./scripts/trust-log.sh demo pass` 21 次，然后 `--tier demo` 打印 auto。在一个 10+ 次运行的技能上记录一次失败，并看到 stderr 上的 ALERT。重置：`> memory/trust.tsv`。

### 构建 5：常设目标 + 目标账本

为什么，用一句话说：你只验证一次的目标就是一个带有时间戳的假设，因此已完成的目标升级为每天重新验证并记录的不变量。

为每个已完成的事情创建一个文件 goals/<name>.md：

```markdown
predicate: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
born: 2026-07-06
source: /goal session 2026-07-06 (fix auth flake)
status: satisfied
last-pass: 2026-07-06
on-violation: wake me. Do not auto-fix.
retire-when: auth module deleted. Retirement is a human decision, logged.
```

谓词规则：一个命令；exit 0 = 不变量成立；便宜、确定、只读。形容词被禁止；如果 shell 脚本无法检查它，检查者也无法检查。非代码谓词同样适用：`find invoices/overdue -mtime +45 | wc -l` 打印 0，`test -s reports/$(date +%Y-%m)-review.md`。

创建 loop/verify-goals.sh：

```shell
##!/usr/bin/env bash
set -uo pipefail
LEDGER="memory/goal-ledger.tsv"; VIOLATIONS=0
for g in goals/*.md; do
  [ -e "$g" ] || continue
  grep -q '^status: retired' "$g" && continue
  pred=$(grep '^predicate:' "$g" | cut -d' ' -f2-); name=$(basename "$g" .md)
  start=$(date +%s%3N)
  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
    sed -i "s/^status:.*/status: satisfied/; s/^last-pass:.*/last-pass: $(date +%F)/" "$g"
  else r=FAIL; VIOLATIONS=$((VIOLATIONS+1)); sed -i "s/^status:.*/status: VIOLATED/" "$g"; fi
  echo -e "$(date -Is)\t$name\t$r\t$(( $(date +%s%3N) - start ))" >> "$LEDGER"
done
[ "$VIOLATIONS" -gt 0 ] && { grep -l '^status: VIOLATED' goals/*.md; exit 1; }
echo "all standing goals hold"
```

启动哨兵（仅检测；修复通过正常管道进行）：

```bash
/loop 1d Run ./verify-goals.sh. If non-zero: for each violated goal, read its
last-pass date and list what merged since (git log --oneline --since=<date>).
Report goal, suspects, on-violation policy. Do not fix anything.
```

毕业法则已经在 CLAUDE.md（构建 1）中：每个通过的 /goal 都编写自己的常设目标。完成即是注册。

你实际会使用的账本查询：

```bash
awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # 最不稳定的目标
grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # 何时破坏
```

不稳定的谓词：隔离（status: retired，备注“需要更好的谓词”），永远不要删除。

检查 5：添加一个谓词为 true 的目标和一个谓词为 false 的目标。`./verify-goals.sh` 退出 1，将第二个翻转为 VIOLATED，并且两者都出现在账本中。删除虚拟目标。

### 构建 6：预算

为什么：每日成本 = tick 数 × 分流 + 命中次数 × (指挥者 + 执行者 + 验证者)。按实际价格（分流 $0.01，指挥者 $0.35，执行者 $0.10，验证者 $0.40）：一个日常清洁工约为 $2.56/天；一个 15 分钟的保姆（将 Fable 放在分流位置）产生相同结果则要 $34/天。读取安静 tick 的模型决定了账单。

创建 loop/scripts/log-cost.sh：

```shell
##!/usr/bin/env bash
echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"
```

创建 loop/scripts/cost-check.sh：

```bash
##!/usr/bin/env bash
set -euo pipefail
F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
case "${1:-}" in
  --budget)
    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
      || { echo "spent \$$spent of \$$2" >&2; exit 1; };;
  --report)
    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
      '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf "  %-10s $%.2f\n",k,s[k]; printf "  TOTAL      $%.2f\n",t}' "$F";;
esac
```

保持平稳的规则：节奏是成本决策（将间隔减半会使下限翻倍）；安静 tick 必须花费美分；循环内努力程度永远不要超过 high（xhigh 用于一次性审查；努力程度是按步骤，而不是按运行）。

检查 6：经过一周的 tick 后，`./scripts/cost-check.sh --report` 在噪声范围内匹配公式。将 DAILY_BUDGET_USD 设置为你愿意浪费的数字。

### 构建 7：可选循环（当它们的条件出现时安装）

共识循环（当调度显示出现 Fable 唤醒但产生 `action: stop` 时安装）。三个廉价模型投票；Fable 在 2/3 时唤醒。投票者永远不会看到彼此的回答。

```bash
V=0
for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do
  llm -m "openrouter/$m" -s "$(cat triage.md)" < /tmp/signals.txt \
    | grep -q "status: actionable" && V=$((V+1))
done
[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: quiet ($V/3)"
```

棘轮循环（当某个数字变得重要时安装）。单调改进或自动回滚；度量标准不能被操纵；已完成的下限成为一个常设目标。

```markdown
/goal Reduce `npm run lint 2>&1 | grep -c warning` to 0.
Permissions: edit src/; commit per fix; re-measure after every change.
Walls: the number NEVER goes up; revert any change that raises it or breaks a
test; never edit lint config to lower it.
Timebox: stop after 3 attempts with no movement; report survivors.
```

对练循环（当你每天发布代码时安装）。构建者和破坏者，彼此对立；双方互不触碰对方的输出；争议交由你处理。

```markdown
/loop 1d [breaker] Read yesterday's merged diffs. Write ONE failing test
exposing a real weakness. Commit under tests/sparring/ tagged @sparring.
Fix nothing. Solid code = say so, write nothing.
/loop 1d [builder] If any @sparring test fails, fix the CODE until it passes.
Never edit, weaken, or delete a sparring test; disputes queue for me.
```

复盘循环（始终安装，每周）。失败变成法律；最多三个提案；需要人类签名。

```markdown
/loop 7d Read this week's exhaust: FAILED in STATE.md, fails in trust.tsv,
FAILs in goal-ledger.tsv, PRs closed unmerged. Extract AT MOST 3 proposals:
a new CLAUDE.md law (quote incidents), a skill fix (same failure repeating),
or a standing goal we lacked. Propose only. Clean week = say so.
```

检查 7：每个可选循环的安装条件都在你的笔记中写在它旁边。推测性地安装它们是系统膨胀的根源。

### 构建 8：运维

创建 Makefile：

```makefile
tick:            ; ./loop/loop.sh
queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo empty
trust:           ; @./loop/scripts/trust-log.sh --render
audit:           ; @./loop/scripts/cost-check.sh --report
goals:           ; @./loop/verify-goals.sh
clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force
```

Cron，当第 2 周开始时：

```markdown
0 7 * * 1-5  cd /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1
30 7 * * *   cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1
```

### 30 天信任计划

不要跳过升级；每个升级都会解锁下一个。

| 周 | 级别 | 你做的事 | 毕业条件 |
| --- | --- | --- | --- |
| 1 | L1 报告 | 构建 1-6；每天手动运行 make tick；阅读所有内容 | 连续 3 次运行路由与你完全相同 |
| 2 | L2 草稿 | cron 开启；喝咖啡时运行 make queue；审查反馈账本 | 2 个技能跨越 20 次记录运行 |
| 3 | L3 发布 | make audit 对照公式；最好的技能无人值守运行 | 1 周，零干预 |
| 4 | L4 成长 | 复盘签署；批准 1 个提议的技能；运行删除通行证 | 你删除了某样东西且没有损坏任何内容 |

运行手册。每个警报的含义以及该怎么做：

| 信号 | 含义 | 行动 |
| --- | --- | --- |
| exit 2（重新路由） | 网关路由器在运行中交换了模型 | 读取检查点；明天重新运行项目；永远不要迭代已交换的输出 |
| stop_reason: refusal | 安全分类器拒绝（HTTP 200，不是错误） | 官方路径：通过回退或中间件回退到 Opus 4.8；如果同一技能重复发生，审计该技能是否存在推理回显或网络/生物相关措辞 |
| exit 3（预算） | 每日支出触及线 | 运行 make audit；找出哪个阶段增长了；修复努力映射，而不是预算 |
| ALERT demoted | 一个已建立的技能降至 90% 以下 | 阅读其最后 3 次失败；通常是规范模式，而非执行者问题 |
| goal VIOLATED | 某件已完成的事情不再成立 | 哨兵给出嫌疑人；修复通过正常管道进行 |
| maker/checker standoff x2 | 双方都不被认为是正确的 | 由你决定，或运行僵局打破者（第三人新审阅者，判定证据，不能折中） |
| verify-goals timeout | 谓词太昂贵 | 那是一个违反；简化谓词 |

### 规则（打印此页）

法律，而非技巧：一个数字、一个“永不”、或者一个检查它的命令。

指挥者计划，执行者工作，两者都不验证。`--allowedTools` 强制执行。

代理通过工作订单交流。done_when = 规范 + 停止条件 + 未来不变量。

在循环分支处花费努力。循环内永远不要超过 high。

安静 tick 花费一分钱，否则循环花费一千块。

如果 shell 脚本无法检查，就不要将其写为目标。

目标毕业；它们不会关闭。`verify-goals.sh` 每天运行，永远如此。

按技能的自主权：20 次运行，95%，自动。降级自动且响亮。

两个账本：信任（执行者）和目标（工作）。喝着咖啡阅读两者。

在 cron 之前计算代谢率。

仓库中的合同：可独立行动 / 需排队 / 会唤醒我。

永远不要迭代你未选择的模型输出。

哨兵检测；管道修复。

在唤醒 Fable 之前先共识。棘轮然后焊接。每日对练。每周复盘。

一次一个毕业标准。每个月，删除一些东西。

来自官方文档：max_tokens 限制思考加文本，拒绝是 HTTP 200，永远不要要求回显推理，旧技能会降低 Fable，全新上下文的验证者优于自我批评。Anthropic 这么说；系统强制执行。

### 结语

从现在起三十天后，如果你执行了检查：一个循环无人值守地发布无聊的工作，一个目标目录重新验证你曾经完成的每一件事，两个账本告诉你关于执行者和工作的真相，并且每周复盘运行会为你的签名提出系统自身的下一个改进。

模型从来不是难题。难题是围绕它构建一些东西，使得当你不看着它时它仍然保持诚实。这就是你刚刚构建的东西。

今晚就从能证明它的二十分钟开始：构建 2 的 verify.sh，构建 3 的第一次手动 tick，以及为你最后完成的一件事创建一个常设目标。

当 verify-goals.sh 第一次捕捉到你确信已经完成的某件事上的无声退化时，你将不再需要关于其余部分的说服。

>- 原文链接： [x.com/Av1dlive/status/20...](https://x.com/Av1dlive/status/2074169173178212621)
>- 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～

这是对 Claude Fable 5 的完整 A-Z 解析：它是什么，以及如何像 100 倍工程师一样使用它

这将彻底改变你与 Claude 合作的方式

在忘记之前，请收藏这 8 个构建

简介

你已经拥有了迄今为止最强大的通用模型，却仍在一次一个地输入提示。本指南将改变这一点。

如果随意使用，它是一种生成令人印象深刻但错误内容的昂贵方式。如果放在系统中使用，它最接近于以每天三美元的价格租用一个员工。

本指南构建了那个系统。不是理念：是实际的文件，按顺序排列，每个文件之后都有一个检查点，这样你在堆叠下一个部件之前就知道它能工作。

你最终将拥有的东西：

一个模型无法协商的 CLAUDE.md（构建 1）

一个每日循环，其中 Fable 5 做出所有决策但几乎不产生 token，便宜的模型做实际工作，独立的验证者评分，一个 bash 脚本持有最终投票（构建 2-3）

一个信任账本，根据测量的通过率自动按技能授予和撤销自主权（构建 4）

一个目标目录，你完成的所有内容每天都持续被重新验证，永不过时，因此没有东西会无声地腐烂（构建 5）

一个自我执行而非让你惊讶的预算（构建 6）

四个可选循环（共识、棘轮、对练、复盘），每个都附带告诉你何时安装它们的条件（构建 7）

一个 cron 计划表，针对系统可能触发的每个警报的运行手册，以及一个 30 天的信任时间表，使其从受监督变为自我扩展。

支撑一切的三条原则，以便你在阅读之前就能预测任何设计决策：

法律，而非技巧。每条规则都有一个编号、一个“永不”、或一个检查它的命令。任何更模糊的东西都会被优化掉。

没有人给自己的作业评分。规划者、执行者、验证者和门禁是四个不同的角色，最后一个角色是确定性的。

没有东西通过后就不再被关注。已完成的工作升级为持续重新验证的恒等式。一个你只验证一次的目标就是一个带有时间戳的假设。

从这开始不再有长篇大论。八个构建，每个都附带文件、命令和一个检查点。

前置条件

claude CLI（Claude Code）且拥有 Fable 5 访问权限     # 启用使用积分，设置 /usage-credits cap
llm CLI + OpenRouter 密钥                             # llm install llm-openrouter
jq, gh, git, make, cron
一个包含测试命令的代码库

你正在构建的内容

your-repo/
  CLAUDE.md                    # 构建 1：宪法
  loop/
    loop.sh                    # 构建 3：心跳
    conductor.md               # 构建 3：路由提示
    triage.md                  # 构建 3：廉价读取器提示
    contract.md                # 构建 2：三个列表
    workers/implement.md       # 构建 3
    workers/verify.md          # 构建 3
    guardrails/verify.sh       # 构建 2：确定性门禁
    scripts/trust-log.sh       # 构建 4
    scripts/log-cost.sh        # 构建 6
    scripts/cost-check.sh      # 构建 6
    quorum.sh                  # 构建 7（可选）
    verify-goals.sh            # 构建 5
    goals/                     # 构建 5：常设目标
    skills/                    # 构建 4：每个员工一个文件
    memory/
      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
  Makefile                     # 构建 8：tick / queue / trust / audit / dream

构建 0：配置引擎（来自官方 Fable 5 文档）

此构建中的所有内容均来自 Anthropic 自己的文档。在编写你自己的任何文件之前，先设置好这些。

规范表：

设置	值	来源
模型字符串	claude-fable-5	模型概述
上下文 / 输出	1M token / 每次请求最多 128k 输出	介绍文档
价格	$10/M 输入，$50/M 输出	介绍文档
思考	自适应，始终开启；thinking: {type:"disabled"} 被拒绝；思考输出仅总结	介绍 + 努力文档
努力程度	low、medium、high、xhigh、max；high = 默认 = 省略参数	努力文档
API 形状	output_config: {"effort": "..."} 在 Messages API 上	努力文档

五个改变构建方式的官方事实：

max_tokens 是思考加上响应文本的硬限制。在 high 和 xhigh 下，设置一个较大的值（从 64k 开始），否则 Fable 会在思考中途空间不足。适用于本指南中的每次 claude -p 调用。

拒绝是 HTTP 200。Fable 5 运行安全分类器（攻击性网络、生物学/生命科学、推理提取）。被拒绝的请求以 stop_reason: "refusal" 作为 SUCCESS 响应返回。你的脚本必须检查停止原因，而不是退出码。官方补救措施：配置服务器端回退或 SDK 中间件，以重新路由到 Opus 4.8。

永远不要要求 Fable 回显其推理。提示或技能中出现“展示你的思考”或“在响应中解释你的推理”会触发 reasoning_extraction 拒绝类别，并触发回退。迁移时审计每个旧技能。改为阅读结构化思考块。

官方提示包。Anthropic 发布了针对 Fable 5 已知行为的经过测试的提示语言。这些直接放入你的提示中；不要将它们压缩得更薄：

反过度规划（用于指挥者和任何交互式会话）：

当你拥有足够的信息可以行动时，就行动。不要重新推导对话中已经确定的事实，
不要重新争论用户已经做出的决定，也不要叙述你不会追求的选择。
如果你在权衡选择，给出推荐，而不是详尽调查。

反过度工程（用于每个执行者提示；这是官方防止过度交付的围栏）：

不要添加功能、重构或引入超出任务要求的抽象。修复 bug 不需要周围的清理工作。
不要为假设的未来需求进行设计：做最简单且有效的事情。
不要为不可能发生的场景添加错误处理或验证。仅在系统边界进行验证。

基于证据的进度声明（用于任何长时间运行；在 Anthropic 的测试中，这几乎消除了虚构的状态报告）：

在报告进度之前，对照本次会话中的工具结果审计每个声明。
只报告你能指出证据的工作；如果某件事尚未验证，请明确说明。
如果测试失败，请连同输出一起说明；如果某个步骤被跳过，请说明。

自主管道提醒（用于每个 cron 驱动的提示；消除“我现在将运行 X”的提前停止）：

你是自主运行的。用户没有在观看，也无法在任务中回答问题。
对于源于原始请求的可逆操作，继续进行，无需询问。
在结束你的回合之前，检查你的最后一段：如果它是一个计划、一个问题或一个关于你尚未完成的工作的承诺，
立即使用工具调用完成该工作。只有当任务完成或你被输入阻挡（只有用户才能提供）时才结束。

官方内存格式（用于梦想者和 memory/learnings/）：

每个文件存储一课，顶部有一行总结。记录修正和已确认的方法，
包括它们为何重要。不要保存仓库已经记录的内容；
更新现有笔记而不是重复；删除后来证明是错误的笔记。

官方验证者指令（文档直接指出：“独立的、全新上下文的验证者子代理通常优于自我批评”）：

建立一种方法，每隔 [X] 检查自己的工作情况。
每隔 [X 间隔] 运行一次，使用子代理根据规范验证你的工作。

检查 0：你脚本中的每个 claude -p 调用在支持的地方都有一个明确的较大的 max_tokens；你的脚本检查 stop_reason: "refusal"；任何提示或技能中都没有“展示你的思考”。

构建 1：宪法（CLAUDE.md）

为什么，用一句话概括：Fable 遵循法律并围绕技巧进行优化，因此每一行都需要一个编号、一个“永不”、或者一个检查它的命令。

创建 CLAUDE.md：

## CLAUDE.md

### 永不（法律；例外需要先询问）
- 未经询问，一次提交中不得超过 200 行更改。
- 未经监督，不得触碰 src/auth/、src/billing/、migrations/ 或生产配置。
- 不得自行评估工作已完成。完成 = 检查通过。
- 不得发明秘密、端点或约定。停止并询问。
- 不得添加依赖项。在 STATE.md 中提议并停止。
- 在循环内永远不要超过 effort high。xhigh 仅用于一次性审查。
- 不得编辑或删除测试以使其通过。那总是失败。
- 不得在响应文本中回显、转录或解释你的内部推理。
  （官方：会在 Fable 5 上触发 reasoning_extraction 拒绝。）
- 当 /goal 条件通过时，在报告成功之前，将条件作为其谓词写入 goals/&lt;name>.md。

### 调度（路由每个任务；第一个匹配获胜；记录到 memory/dispatch.tsv）
| 模型           | 边际 | 消耗 | 智能 | 品味 |
|-----------------|----------|----------|--------------|-------|
| claude-fable-5  | 2（积分） | 3     | 10           | 10    |
| claude-opus-4-8 | 7（订阅）| 6        | 8            | 9     |
| claude-sonnet-5 | 9（订阅）| 8        | 7            | 7     |
| codex（第二订阅）| 9        | 10       | 9            | 5     |
1. 决策（计划/审查/路由/僵局）-> fable-5，effort high，只读。
2. 读取量 >50k token（日志/PDF/截图）-> codex。永远不要用 fable。
3. 发送给用户（UI/API/文案）-> 品味 >= 8 获得最终审阅。
4. 规范完整 -> sonnet-5，effort medium。
5. 其他情况 sonnet-5；失败时直接升级一级，无需询问。

### 词汇
- “智能” = 难度最高的、无监督处理的问题
- “品味” = UI/UX、代码质量、API 设计、文案
- “完成” = 谓词通过；其他都不算
- “小” = 少于 50 行更改；“快速” = 占用你少于 10 分钟
- “清理” = 行为完全相同，verify.sh 在前后都为绿色

### 完成
- 每个任务在开始工作之前都有一个机器可检查的 done_when。
- 一个既未看到计划也未看到草稿的全新上下文代理将根据该条件进行验证。
- guardrails/verify.sh 拥有最终投票。
- 偏离：保守选项，记录到 IMPLEMENTATION.md，继续。
- 制造者和检查者两次不一致 -> 停止，排队等待人类处理。

将数字和路径编辑为你自己的。工作流程特定的材料（PR 流程、发布检查清单）放在 skills/ 中，而不是这里。

检查 1：对于每一行，询问：模型能否以 80% 的合规度声称成功？如果是，则用数字或“永不”重写。wc -l CLAUDE.md 少于 150。

构建 2：围墙和门禁

为什么：在第一次心跳之前必须声明爆炸半径，并且一个 bash 脚本必须持有最终投票。

创建 loop/contract.md：

### 可独立行动
在分支上起草 PR；修复 lint/测试债务；更新 STATE.md；标记 issue

### 需排队等待我
认证、支付、迁移；任何低于“自动”级别的技能；任何超过 400 行的差异

### 会唤醒我
同一项目验证失败两次
网关路由器在运行中交换了模型
每日预算超支
任何请求秘密的操作
某个常设目标被违反

创建 loop/guardrails/verify.sh（根据你的技术栈编辑）：

##!/usr/bin/env bash
set -e
npm run typecheck --if-present
npm test --if-present
npm run lint --if-present

检查 2：./loop/guardrails/verify.sh 运行并在你当前仓库中退出 0。如果现在失败，先修复它；整个系统依赖于这个脚本。

构建 3：心跳

创建 loop/triage.md：

你接收最近的提交、开放的 Issue 和 CI 运行。仅输出发现：
- finding: &lt;一行>
  evidence: &lt;commit/issue/run id>
  status: actionable | informational
没有修复，没有意见。无内容可报告 = 输出确切的 "status: quiet"。
任何涉及认证、支付、迁移、秘密的内容 = 始终 actionable，标注 "contract-sensitive"。

创建 loop/conductor.md：

你是指挥者。你不编写代码。你不编辑文件。
1. 阅读 STATE、信任账本、以下合同。不要依赖它们在你记忆中的版本。
2. 挑选唯一的一个最高价值的可操作项目。
   contract-sensitive、模糊或可能 >400 行差异 -> action: queue
   没有值得做的事情 -> action: stop
3. 否则 action: execute，并附带一个普通模型也能遵循的规范。
仅输出此 JSON：
{ "action": "execute|queue|stop", "item": "...", "skill": "&lt;kebab-case，
跨运行稳定>", "spec": "...", "done_when": ["&lt;可验证的>", ...] }
你是昂贵的。请简短。你的输出是一个决策，不是一篇论文。

创建 loop/workers/implement.md：

你接收一个工作订单（JSON）。精确执行规范。
仅向 done_when 执行下一步。小的差异获胜。
缺少凭据或未记录的决策 -> 停止，将问题写入 IMPLEMENTATION.md。永远不要发明秘密或约定。
在 IMPLEMENTATION.md 中记录你做了什么以及为什么（最多 3 行）。

创建 loop/workers/verify.md：

你接收一个规范和一个差异，仅此而已。仅判定你眼前的内容。
1. 差异是否满足每个 done_when？引用行号。
2. 规范范围之外的任何内容？立刻失败。删除或跳过测试？立刻失败。
仅输出一行： "PASS: &lt;原因>" 或 "FAIL: &lt;原因>"。
制造者曾充满信心。但那不是证据。

创建 loop/loop.sh：

##!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")"
MAX_ITERS="${MAX_ITERS:-10}"
DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"

./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3

for ((i=1; i&lt;=MAX_ITERS; i++)); do
  # 1 分流：安静心跳门，~$0.01
  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
    gh run list --limit 10 2>/dev/null || true; } \
    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
  ./scripts/log-cost.sh triage 0.01
  grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }

  # 2 指挥：Fable，xhigh，全新上下文，只读，JSON 输出
  claude -p "$(cat conductor.md)
STATE: $(cat memory/STATE.md)
TRUST: $(./scripts/trust-log.sh --render)
CONTRACT: $(cat contract.md)" \
    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
    --output-format json > /tmp/c.json
  ./scripts/log-cost.sh conductor 0.35

  # 2a 路由容差：永远不要迭代你未选择的模型输出
  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
  [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }

  jq -r '.result' /tmp/c.json > work-order.json
  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
  [[ "$ACTION" == stop  ]] && exit 0
  [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }

  # 3 执行：廉价执行者，隔离工作树
  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
  ./scripts/log-cost.sh worker 0.10

  # 4 验证：全新 Fable，无工具，仅看到规范 + 差异
  V=$(claude -p "$(cat workers/verify.md)
SPEC: $(jq -r .spec work-order.json)
DIFF: $(cd "$WT" && git diff)" \
    --model claude-fable-5 --effort high --allowedTools "" \
    --output-format json | jq -r .result)
  ./scripts/log-cost.sh verifier 0.40

  # 5 门禁：确定性；然后账本；仅自动级别时推送
  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
    ./scripts/trust-log.sh "$SKILL" pass
    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
      echo "- shipped: $SKILL" >> memory/STATE.md
    else
      echo "- review: $SKILL in $WT" >> memory/STATE.md
    fi
  else
    ./scripts/trust-log.sh "$SKILL" fail
    echo "- FAILED: $SKILL in $WT" >> memory/STATE.md
  fi
  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
done
exit 1   # 迭代上限但未停止：检查 STATE.md

退出映射：0 安静/完成，1 上限，2 重新路由，3 预算。全部有标签，故意为之。

检查 3：chmod +x loop.sh guardrails/verify.sh 然后手动运行一次 ./loop.sh。确认：一个安静的仓库以大约一分钱退出 0；一个有可操作事项的仓库生成包含所有五个字段的 work-order.json 以及在 STATE.md 中的裁决行。

构建 4：信任账本

为什么：“随着信任增长提高自主权”不是一个机制；一个带有级别规则的 TSV 文件才是。自主权是按技能，而不是按循环。

创建 loop/scripts/trust-log.sh：

##!/usr/bin/env bash
## 用法：trust-log.sh &lt;技能> &lt;pass|fail> | --render | --tier &lt;技能>
set -euo pipefail
F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
  rate=(r>0)?p/r:0
  if (r>=20 && rate>=0.95) print "auto"
  else if (r&lt;10 || rate&lt;0.90) print "watch"
  else print "queue"}'; }
case "${1:-}" in
  --render)
    printf "%-20s %5s %5s %6s %s\n" skill runs pass rate tier
    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
        "$(tier_of "$r" "$p")"; done &lt; "$F";;
  --tier)
    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
    tier_of "$(cut -f2 &lt;&lt;&lt;"$line")" "$(cut -f3 &lt;&lt;&lt;"$line")";;
  *)
    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
    if [ "$2" = fail ]; then
      runs=$(grep -P "^${1}\t" "$F" | cut -f2)
      [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \
        && echo "ALERT: $1 demoted to watch after $runs runs" >&2 || true
    fi;;
esac

检查 4：运行 ./scripts/trust-log.sh demo pass 21 次，然后 --tier demo 打印 auto。在一个 10+ 次运行的技能上记录一次失败，并看到 stderr 上的 ALERT。重置：> memory/trust.tsv。

构建 5：常设目标 + 目标账本

为什么，用一句话说：你只验证一次的目标就是一个带有时间戳的假设，因此已完成的目标升级为每天重新验证并记录的不变量。

为每个已完成的事情创建一个文件 goals/<name>.md：

predicate: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
born: 2026-07-06
source: /goal session 2026-07-06 (fix auth flake)
status: satisfied
last-pass: 2026-07-06
on-violation: wake me. Do not auto-fix.
retire-when: auth module deleted. Retirement is a human decision, logged.

谓词规则：一个命令；exit 0 = 不变量成立；便宜、确定、只读。形容词被禁止；如果 shell 脚本无法检查它，检查者也无法检查。非代码谓词同样适用：find invoices/overdue -mtime +45 | wc -l 打印 0，test -s reports/$(date +%Y-%m)-review.md。

创建 loop/verify-goals.sh：

##!/usr/bin/env bash
set -uo pipefail
LEDGER="memory/goal-ledger.tsv"; VIOLATIONS=0
for g in goals/*.md; do
  [ -e "$g" ] || continue
  grep -q '^status: retired' "$g" && continue
  pred=$(grep '^predicate:' "$g" | cut -d' ' -f2-); name=$(basename "$g" .md)
  start=$(date +%s%3N)
  if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass
    sed -i "s/^status:.*/status: satisfied/; s/^last-pass:.*/last-pass: $(date +%F)/" "$g"
  else r=FAIL; VIOLATIONS=$((VIOLATIONS+1)); sed -i "s/^status:.*/status: VIOLATED/" "$g"; fi
  echo -e "$(date -Is)\t$name\t$r\t$(( $(date +%s%3N) - start ))" >> "$LEDGER"
done
[ "$VIOLATIONS" -gt 0 ] && { grep -l '^status: VIOLATED' goals/*.md; exit 1; }
echo "all standing goals hold"

启动哨兵（仅检测；修复通过正常管道进行）：

/loop 1d Run ./verify-goals.sh. If non-zero: for each violated goal, read its
last-pass date and list what merged since (git log --oneline --since=&lt;date>).
Report goal, suspects, on-violation policy. Do not fix anything.

毕业法则已经在 CLAUDE.md（构建 1）中：每个通过的 /goal 都编写自己的常设目标。完成即是注册。

你实际会使用的账本查询：

awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # 最不稳定的目标
grep &lt;goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # 何时破坏

不稳定的谓词：隔离（status: retired，备注“需要更好的谓词”），永远不要删除。

检查 5：添加一个谓词为 true 的目标和一个谓词为 false 的目标。./verify-goals.sh 退出 1，将第二个翻转为 VIOLATED，并且两者都出现在账本中。删除虚拟目标。

构建 6：预算

创建 loop/scripts/log-cost.sh：

##!/usr/bin/env bash
echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"

创建 loop/scripts/cost-check.sh：

##!/usr/bin/env bash
set -euo pipefail
F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
case "${1:-}" in
  --budget)
    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
      || { echo "spent \$$spent of \$$2" >&2; exit 1; };;
  --report)
    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
      '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf "  %-10s $%.2f\n",k,s[k]; printf "  TOTAL      $%.2f\n",t}' "$F";;
esac

检查 6：经过一周的 tick 后，./scripts/cost-check.sh --report 在噪声范围内匹配公式。将 DAILY_BUDGET_USD 设置为你愿意浪费的数字。

构建 7：可选循环（当它们的条件出现时安装）

共识循环（当调度显示出现 Fable 唤醒但产生 action: stop 时安装）。三个廉价模型投票；Fable 在 2/3 时唤醒。投票者永远不会看到彼此的回答。

V=0
for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do
  llm -m "openrouter/$m" -s "$(cat triage.md)" &lt; /tmp/signals.txt \
    | grep -q "status: actionable" && V=$((V+1))
done
[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: quiet ($V/3)"

棘轮循环（当某个数字变得重要时安装）。单调改进或自动回滚；度量标准不能被操纵；已完成的下限成为一个常设目标。

/goal Reduce `npm run lint 2>&1 | grep -c warning` to 0.
Permissions: edit src/; commit per fix; re-measure after every change.
Walls: the number NEVER goes up; revert any change that raises it or breaks a
test; never edit lint config to lower it.
Timebox: stop after 3 attempts with no movement; report survivors.

对练循环（当你每天发布代码时安装）。构建者和破坏者，彼此对立；双方互不触碰对方的输出；争议交由你处理。

/loop 1d [breaker] Read yesterday's merged diffs. Write ONE failing test
exposing a real weakness. Commit under tests/sparring/ tagged @sparring.
Fix nothing. Solid code = say so, write nothing.
/loop 1d [builder] If any @sparring test fails, fix the CODE until it passes.
Never edit, weaken, or delete a sparring test; disputes queue for me.

复盘循环（始终安装，每周）。失败变成法律；最多三个提案；需要人类签名。

/loop 7d Read this week's exhaust: FAILED in STATE.md, fails in trust.tsv,
FAILs in goal-ledger.tsv, PRs closed unmerged. Extract AT MOST 3 proposals:
a new CLAUDE.md law (quote incidents), a skill fix (same failure repeating),
or a standing goal we lacked. Propose only. Clean week = say so.

检查 7：每个可选循环的安装条件都在你的笔记中写在它旁边。推测性地安装它们是系统膨胀的根源。

构建 8：运维

创建 Makefile：

tick:            ; ./loop/loop.sh
queue:           ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo empty
trust:           ; @./loop/scripts/trust-log.sh --render
audit:           ; @./loop/scripts/cost-check.sh --report
goals:           ; @./loop/verify-goals.sh
clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force

Cron，当第 2 周开始时：

0 7 * * 1-5  cd /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1
30 7 * * *   cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1

30 天信任计划

不要跳过升级；每个升级都会解锁下一个。

周	级别	你做的事	毕业条件
1	L1 报告	构建 1-6；每天手动运行 make tick；阅读所有内容	连续 3 次运行路由与你完全相同
2	L2 草稿	cron 开启；喝咖啡时运行 make queue；审查反馈账本	2 个技能跨越 20 次记录运行
3	L3 发布	make audit 对照公式；最好的技能无人值守运行	1 周，零干预
4	L4 成长	复盘签署；批准 1 个提议的技能；运行删除通行证	你删除了某样东西且没有损坏任何内容

运行手册。每个警报的含义以及该怎么做：

信号	含义	行动
exit 2（重新路由）	网关路由器在运行中交换了模型	读取检查点；明天重新运行项目；永远不要迭代已交换的输出
stop_reason: refusal	安全分类器拒绝（HTTP 200，不是错误）	官方路径：通过回退或中间件回退到 Opus 4.8；如果同一技能重复发生，审计该技能是否存在推理回显或网络/生物相关措辞
exit 3（预算）	每日支出触及线	运行 make audit；找出哪个阶段增长了；修复努力映射，而不是预算
ALERT demoted	一个已建立的技能降至 90% 以下	阅读其最后 3 次失败；通常是规范模式，而非执行者问题
goal VIOLATED	某件已完成的事情不再成立	哨兵给出嫌疑人；修复通过正常管道进行
maker/checker standoff x2	双方都不被认为是正确的	由你决定，或运行僵局打破者（第三人新审阅者，判定证据，不能折中）
verify-goals timeout	谓词太昂贵	那是一个违反；简化谓词

规则（打印此页）

法律，而非技巧：一个数字、一个“永不”、或者一个检查它的命令。

指挥者计划，执行者工作，两者都不验证。--allowedTools 强制执行。

代理通过工作订单交流。done_when = 规范 + 停止条件 + 未来不变量。

在循环分支处花费努力。循环内永远不要超过 high。

安静 tick 花费一分钱，否则循环花费一千块。

如果 shell 脚本无法检查，就不要将其写为目标。

目标毕业；它们不会关闭。verify-goals.sh 每天运行，永远如此。

按技能的自主权：20 次运行，95%，自动。降级自动且响亮。

两个账本：信任（执行者）和目标（工作）。喝着咖啡阅读两者。

在 cron 之前计算代谢率。

仓库中的合同：可独立行动 / 需排队 / 会唤醒我。

永远不要迭代你未选择的模型输出。

哨兵检测；管道修复。

在唤醒 Fable 之前先共识。棘轮然后焊接。每日对练。每周复盘。

一次一个毕业标准。每个月，删除一些东西。

结语

模型从来不是难题。难题是围绕它构建一些东西，使得当你不看着它时它仍然保持诚实。这就是你刚刚构建的东西。

今晚就从能证明它的二十分钟开始：构建 2 的 verify.sh，构建 3 的第一次手动 tick，以及为你最后完成的一件事创建一个常设目标。

当 verify-goals.sh 第一次捕捉到你确信已经完成的某件事上的无声退化时，你将不再需要关于其余部分的说服。

原文链接： x.com/Av1dlive/status/20...

登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～

使用Fable 5构建Agentic OS：建造者指南

简介

构建 0：配置引擎（来自官方 Fable 5 文档）

构建 1：宪法（CLAUDE.md）

构建 2：围墙和门禁

构建 3：心跳

构建 4：信任账本

构建 5：常设目标 + 目标账本

构建 6：预算

构建 7：可选循环（当它们的条件出现时安装）

构建 8：运维

30 天信任计划

规则（打印此页）

结语

相关文章

0 条评论

请输入验证码

登链社区服务条款与隐私政策

登链社区服务条款与隐私政策

登链社区用户服务条款

一、定义

二、服务内容

三、用户权利义务

四、知识产权保护

五、有限保证及服务免责

六、服务变更、中断或终止

七、通知和送达

八、投诉处理

九、法律适用、争议管辖及其他

隐私政策

一、登链社区可能收集的信息内容

二、登链社区收集信息的使用规则

三、登链社区如何共享、转让、公开披露您的个人信息

四、登链社区如何使用 Cookie 和同类技术

五、登链社区如何保护和保存您的个人信息

六、您如何管理个人信息

七、未成年人信息的保护

八、隐私政策的修订和更新

如何联系我们