Fable 5를 활용하여 에이전트 OS 구축하는 방법 (빌더 가이드)

1claude CLI (Claude Code) with Fable 5 access     # usage credits enabled, /usage-credits cap set
2llm CLI + OpenRouter key                          # llm install llm-openrouter
3jq, gh, git, make, cron
4a repo with a test command

1your-repo/
2  CLAUDE.md                    # BUILD 1: the constitution
3  loop/
4    loop.sh                    # BUILD 3: the heartbeat
5    conductor.md               # BUILD 3: routing prompt
6    triage.md                  # BUILD 3: cheap reader prompt
7    contract.md                # BUILD 2: the three lists
8    workers/implement.md       # BUILD 3
9    workers/verify.md          # BUILD 3
10    guardrails/verify.sh       # BUILD 2: deterministic gate
11    scripts/trust-log.sh       # BUILD 4
12    scripts/log-cost.sh        # BUILD 6
13    scripts/cost-check.sh      # BUILD 6
14    quorum.sh                  # BUILD 7 (optional)
15    verify-goals.sh            # BUILD 5
16    goals/                     # BUILD 5: standing goals
17    skills/                    # BUILD 4: one file per employee
18    memory/
19      STATE.md  trust.tsv  goal-ledger.tsv  dispatch.tsv  usage.log
20  Makefile                     # BUILD 8: tick / queue / trust / audit / dream

1When you have enough information to act, act. Do not re-derive facts already
2established in the conversation, re-litigate a decision the user has already
3made, or narrate options you will not pursue. If you are weighing a choice,
4give a recommendation, not an exhaustive survey.

1Don't add features, refactor, or introduce abstractions beyond what the task
2requires. A bug fix doesn't need surrounding cleanup. Don't design for
3hypothetical future requirements: do the simplest thing that works well.
4Don't add error handling or validation for scenarios that cannot happen.
5Only validate at system boundaries.

1Before reporting progress, audit each claim against a tool result from this
2session. Only report work you can point to evidence for; if something is not
3yet verified, say so explicitly. If tests fail, say so with the output; if a
4step was skipped, say that.

1You are operating autonomously. The user is not watching and cannot answer
2questions mid-task. For reversible actions that follow from the original
3request, proceed without asking. Before ending your turn, check your last
4paragraph: if it is a plan, a question, or a promise about work you have not
5done, do that work now with tool calls. End only when the task is complete
6or you are blocked on input only the user can provide.

1Store one lesson per file with a one-line summary at the top. Record
2corrections and confirmed approaches alike, including why they mattered.
3Don't save what the repo already records; update existing notes rather than
4duplicating; delete notes that turn out to be wrong.

1Establish a method for checking your own work at an interval of [X] as you
2build. Run this every [X interval], verifying your work with subagents
3against the specification.

1# CLAUDE.md
2
3## NEVER (laws; exceptions require asking first)
4- Never exceed 200 changed lines in one commit without asking.
5- Never touch src/auth/, src/billing/, migrations/, or prod config unattended.
6- Never report work as done from your own assessment. Done = the check passed.
7- Never invent a secret, an endpoint, or a convention. Stop and ask.
8- Never add a dependency. Propose it in STATE.md and stop.
9- Never exceed effort high inside any loop. xhigh is for one-shot reviews only.
10- Never edit or delete a test to make it pass. That is a fail, always.
11- Never echo, transcribe, or explain your internal reasoning in response
12  text. (Official: triggers reasoning_extraction refusals on Fable 5.)
13- When a /goal condition passes, write goals/<name>.md with the condition as
14  its predicate before reporting success.
15
16## DISPATCH (route every task; first match wins; log to memory/dispatch.tsv)
17| model           | marginal | appetite | intelligence | taste |
18|-----------------|----------|----------|--------------|-------|
19| claude-fable-5  | 2 (credits) | 3     | 10           | 10    |
20| claude-opus-4-8 | 7 (sub)  | 6        | 8            | 9     |
21| claude-sonnet-5 | 9 (sub)  | 8        | 7            | 7     |
22| codex (2nd sub) | 9        | 10       | 9            | 5     |
231. Decision (plan/review/route/standoff) -> fable-5, effort high, read-only.
242. Reads >50k tokens (logs/PDFs/screenshots) -> codex. Never fable.
253. Ships to users (UI/API/copy) -> taste >= 8 gets final pass.
264. Spec complete -> sonnet-5, effort medium.
275. Else sonnet-5; escalate one rung on a miss without asking.
28
29## WORDS
30- "intelligence" = hardest problem handled unsupervised
31- "taste" = UI/UX, code quality, API design, copy
32- "done" = the predicate passes; nothing else
33- "small" = under 50 changed lines; "quick" = under 10 minutes of your time
34- "cleanup" = behavior identical, verify.sh green before and after
35
36## DONE
37- Every task has a machine-checkable done_when before work starts.
38- A fresh-context agent that saw neither plan nor draft verifies against it.
39- guardrails/verify.sh has the final vote.
40- Deviations: conservative option, log to IMPLEMENTATION.md, continue.
41- Maker and checker disagree twice -> stop, queue for a human.

1## acts alone
2draft PRs on branches; fix lint/test debt; update STATE.md; label issues
3
4## queues for me
5auth, payments, migrations; any skill below "auto" tier; any diff > 400 lines
6
7## wakes me up
8verify fails twice on the same item
9safeguard router swapped models mid-run
10daily budget breached
11anything requests a secret
12a standing goal is VIOLATED

1#!/usr/bin/env bash
2set -e
3npm run typecheck --if-present
4npm test --if-present
5npm run lint --if-present

1You receive recent commits, open issues, and CI runs. Output ONLY findings:
2- finding: <one line>
3  evidence: <commit/issue/run id>
4  status: actionable | informational
5No fixes, no opinions. Nothing to report = output exactly "status: quiet".
6Anything touching auth, payments, migrations, secrets = always actionable,
7noted "contract-sensitive".

1You are the conductor. You do not write code. You do not edit files.
21. Read STATE, TRUST LEDGER, CONTRACT below. Do not trust memory of them.
32. Pick the ONE highest-value actionable item.
4   contract-sensitive, ambiguous, or likely >400-line diff -> action: queue
5   nothing worth doing -> action: stop
63. Else action: execute, with a spec a mediocre model can follow.
7Output ONLY this JSON:
8{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case,
9stable across runs>", "spec": "...", "done_when": ["<verifiable>", ...] }
10You are expensive. Be brief. Your output is a decision, not an essay.

1You receive a work order (JSON). Execute the spec exactly.
2Do the ONE next step toward done_when. Small diffs win.
3Missing credential or undocumented decision -> STOP, write the question to
4IMPLEMENTATION.md. Never invent secrets or conventions.
5Record what you did and why in IMPLEMENTATION.md (3 lines max).

1You receive a SPEC and a DIFF, nothing else. Judge only what is in front of you.
21. Does the diff satisfy every done_when? Cite lines.
32. Anything outside the spec's scope? Instant fail. Deleted/skipped tests? Instant fail.
4Output exactly one line: "PASS: <reason>" or "FAIL: <reason>".
5The maker was confident. That is not evidence.

1#!/usr/bin/env bash
2set -euo pipefail
3cd "$(dirname "$0")"
4MAX_ITERS="${MAX_ITERS:-10}"
5DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"
6CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"
7WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"
8
9./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
10
11for ((i=1; i<=MAX_ITERS; i++)); do
12  # 1 TRIAGE: quiet-tick gate, ~$0.01
13  { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \
14    gh run list --limit 10 2>/dev/null || true; } \
15    | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md
16  ./scripts/log-cost.sh triage 0.01
17  grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }
18
19  # 2 CONDUCT: Fable, xhigh, fresh context, read-only, JSON out
20  claude -p "$(cat conductor.md)
21STATE: $(cat memory/STATE.md)
22TRUST: $(./scripts/trust-log.sh --render)
23CONTRACT: $(cat contract.md)" \
24    --model claude-fable-5 --effort xhigh --allowedTools "Read" \
25    --output-format json > /tmp/c.json
26  ./scripts/log-cost.sh conductor 0.35
27
28  # 2a ROUTE-TOLERANCE: never iterate on a model you didn't choose
29  SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)
30  [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }
31
32  jq -r '.result' /tmp/c.json > work-order.json
33  SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)
34  [[ "$ACTION" == stop  ]] && exit 0
35  [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }
36
37  # 3 EXECUTE: cheap worker, isolated worktree
38  WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null
39  ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \
40      "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )
41  ./scripts/log-cost.sh worker 0.10
42
43  # 4 VERIFY: fresh Fable, no tools, sees only spec + diff
44  V=$(claude -p "$(cat workers/verify.md)
45SPEC: $(jq -r .spec work-order.json)
46DIFF: $(cd "$WT" && git diff)" \
47    --model claude-fable-5 --effort high --allowedTools "" \
48    --output-format json | jq -r .result)
49  ./scripts/log-cost.sh verifier 0.40
50
51  # 5 GATE: deterministic; then ledger; ship only at auto tier
52  if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then
53    ./scripts/trust-log.sh "$SKILL" pass
54    if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then
55      ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )
56      echo "- shipped: $SKILL" >> memory/STATE.md
57    else
58      echo "- review: $SKILL in $WT" >> memory/STATE.md
59    fi
60  else
61    ./scripts/trust-log.sh "$SKILL" fail
62    echo "- FAILED: $SKILL in $WT" >> memory/STATE.md
63  fi
64  ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 3
65done
66exit 1   # iteration cap without stop: check STATE.md

1#!/usr/bin/env bash
2# usage: trust-log.sh <skill> <pass|fail> | --render | --tier <skill>
3set -euo pipefail
4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"
5tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{
6  rate=(r>0)?p/r:0
7  if (r>=20 && rate>=0.95) print "auto"
8  else if (r<10 || rate<0.90) print "watch"
9  else print "queue"}'; }
10case "${1:-}" in
11  --render)
12    printf "%-20s %5s %5s %6s %s\n" skill runs pass rate tier
13    while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue
14      printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \
15        "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \
16        "$(tier_of "$r" "$p")"; done < "$F";;
17  --tier)
18    line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")
19    tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;
20  *)
21    awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}
22      $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}
23      END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"
24    if [ "$2" = fail ]; then
25      runs=$(grep -P "^${1}\t" "$F" | cut -f2)
26      [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \
27        && echo "ALERT: $1 demoted to watch after $runs runs" >&2 || true
28    fi;;
29esac

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

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

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

1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5   # 가장 불안정한 것
2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1                                      # 언제 깨졌는지

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

1#!/usr/bin/env bash
2set -euo pipefail
3F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)
4case "${1:-}" in
5  --budget)
6    spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")
7    awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \
8      || { echo "지출액 \$$spent / 예산 \$$2" >&2; exit 1; };;
9  --report)
10    awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \
11      '$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";;
12esac

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

1/goal `npm run lint 2>&1 | grep -c warning` 을 0 으로 줄이기.
2권한: src/ 편집; 수정마다 커밋; 모든 변경 후 재측정.
3제약: 숫자는 절대 올라가지 않음; 숫자를 올리거나 테스트를 깨는 변경은 되돌리기;
4lint 설정을 낮추기 위해 편집 금지.
5시간 제한: 움직임 없이 3 회 시도 후 중단; 생존자 보고.

1/loop 1d [breaker] 어제 병합된 diff 를 읽으세요. 실제 약점을 드러내는
2하나의 실패하는 테스트를 작성하세요. tests/sparring/ 아래에 @sparring 태그로 커밋하세요.
3아무것도 수정하지 마세요. 견고한 코드 = 그렇게 말하고, 아무것도 작성하지 마세요.
4/loop 1d [builder] @sparring 테스트가 실패하면, 통과할 때까지 CODE 를 수정하세요.
5스파링 테스트를 절대 편집, 약화 또는 삭제하지 마세요; 분쟁은 나에게 대기하세요.

1/loop 7d 이번 주의 폐기물을 읽으세요: STATE.md 의 FAILED, trust.tsv 의 실패,
2goal-ledger.tsv 의 FAIL, 병합되지 않고 닫힌 PR. 최대 3 개의 제안을 추출하세요:
3새로운 CLAUDE.md 규칙 (사례 인용), 스킬 수정 (동일한 실패 반복),
4또는 우리에게 없던 상시 목표. 제안만 하세요. 깨끗한 주 = 그렇게 말하세요.

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

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