git:20260913.70cacbc to git:20260913.d34c425

---

name: model-orchestration

description: >-

Apply the fixed model-role and thinking-effort policy whenever work is delegated to subagents

or a model/effort choice is made: the orchestrator (top-tier model, Fable) DIRECTLY owns

설계·기획·분배·리뷰 — sets direction, reviews plan/spec docs, improves shipped features, and hunts

perf/security problems; core implementation, test authoring/execution

(E2E included), and code verification/V&V go to Opus at xhigh or above;

repetitive/simple implementation goes to Sonnet at high or above — Sonnet is never used for

tests or verification; plan/spec drafts may be produced by Opus from a Fable direction brief,

but the review/decision is always Fable's. Never delegate below the effort floors. Use whenever

you are about to spawn an Agent/Task/Workflow worker, pick a model for a subtask, set a

thinking/effort level, or assign verification. Trigger on "위임해", "오케스트레이션", "모델 역할분담", "어떤 모델로",

"effort 얼마로", "서브에이전트", "delegate this", "which model should". Fire even when the

user doesn't name the policy — any delegation is in scope.

---

# Model Orchestration Policy

**What is policy and what is vocabulary.** The policy is the role split — orchestrator ≠ builder ≠

verifier — and the rule that verification never goes to a lower tier than the work it verifies.

`Fable` · `Opus` · `Sonnet` and the effort levels (`xhigh` · `high` · `max`) are Claude Code

vocabulary. On Codex, OpenCode, or Antigravity apply the same split with that vendor's top tier for

orchestration and verification and its mid tier for repetitive implementation; an effort knob that

does not exist there is not a violation — putting verification on a lower tier is.

A fixed role split between model tiers, set by the user (2026-07-04, revised 2026-07-07 and

2026-08-02 — *"설계·분배·기획·리뷰는 Fable5, 핵심 구현·테스트·검증은 opus5, 반복·단순 구현은

sonnet"*). The premise is

**quality-over-cost**: delegation floors are set at the effort levels Anthropic itself

recommends for intelligence-sensitive work ("start with xhigh for coding and agentic use

cases, high as the minimum for most intelligence-sensitive workloads" — official effort

guidance), not at the cost-saving end ("low ... like subagents"). When this policy and a

cost instinct conflict, the policy wins; surface the cost, don't silently downgrade.

## Role split

| Role | Who | Effort floor | Duties |

|------|-----|--------------|--------|

| **Orchestrator + Product Manager** | Top-tier session model (Fable) | session level | 설계·기획·분배·**리뷰** 전부. Directly: 서비스 방향성 수립·논의, 설계 결정·트레이드오프 확정, 작업 분배, 기획/스펙문서 **리뷰·중재**, 기개발 기능 **개선**, 문제점(성능·보안) 발굴 — see below |

| **Core builder + Tester + V&V** | `opus` | **xhigh** (or `max`) | **핵심 구현**(새 설계 표면·경계 판단이 남는 것) + **테스트 작성·실행**(E2E 포함) + **코드 리뷰·검증/V&V**(fresh instance). 기획/스펙 문서 *초안*은 Fable의 방향 브리프를 받아 작성 가능하되, 확정은 Fable 리뷰를 거친다. **리뷰의 분업**: 설계·기획·스펙 문서 리뷰 = Fable / 코드(diff) 리뷰 = Opus V&V |

| **Repetitive builder + read-only assist** | `sonnet` | **high** (or above) | **반복·단순 구현** — 확립된 패턴의 적용, 설계 판단이 이미 끝난 기계적 구현 (산출물은 Opus 교차검증) + 리서치 스윕. **테스트·검증 투입 금지** |

| **Orchestrator stand-in** (quota exhausted) | `opus` @ `max` | max | Takes over orchestration via a handoff — see "Orchestrator handoff" |

The orchestrator assigns a thinking/effort level **per task** at delegation time. Delegating

below a floor is a policy violation, not a tuning choice.

## The orchestrator's own lane: direction, review, judgment

The orchestrator authors **direction**, not documents. 서비스 방향성(where the product goes),

스펙 리뷰(is this plan right?), 기능 개선(what should get better in what shipped?), and

성능·보안 문제 발굴 stay in the orchestrator's window — that's where user intent, constraints,

and history live, and judgment is the one thing a delegation prompt can't carry.

Document *drafting* is delegated to Opus with a direction brief (intent, constraints, decided

trade-offs). This buys an author≠reviewer split for documents themselves: **Opus writes, the

orchestrator reviews** — a draft you review with fresh eyes gets scrutiny your own draft never

would. For 기획/스펙문서 리뷰, run the [[multi-persona-review]] skill (3–5 disjoint persona

reviewers, severity-ranked synthesis) instead of a single-pass read; the orchestrator arbitrates

its findings rather than line-editing alone.

## Routing test

Before routing to any model: **deterministic transforms don't get a model at all.** A rename,

a format sweep, a mechanical find-and-replace is `sed`/`grep`/script work — spending model

tokens on what code answers deterministically fails the routing test at step zero.

Past that gate (2026-08-02 사용자 결정):

- **Core implementation, all tests, anything that judges code** — new design surface, boundary

decisions, test authoring and execution (E2E included), code verification/V&V — route to

**Opus @ xhigh+**.

- **Repetitive/simple implementation** — applying an established pattern where the design

decisions are already made (N번째 유사 변환, 확정 스펙의 기계적 구현) — routes to

**Sonnet @ high+**, and its output gets Opus cross-verification before it gates anything.

The routing question is *"새 판단이 남아 있는가?"* — 남아 있으면 핵심(Opus), 없으면 반복(Sonnet).

- **Read-only assists** (research sweeps) may also go to Sonnet; tests and verification never do.

- **Judgment-free implementation whose pass condition is a command** — the repetitive lane above

stays the default; only when every predicate in the next section holds may that work go to an

external executor instead.

- **Korean the user will read** · **shorter and better structured** — an external advisory

round-trip. Which provider takes which is `external-model-consult`'s provider table; that table

is the SSOT and is not copied here.

- **A judgment that needs several perspectives** → [[multi-persona-review]] (native panel). **One

non-Claude perspective** → `external-model-consult` persona mode. A panel that mixes both asks

the user before it runs, and that gate belongs to [[multi-persona-review]].

- 설계·기획·분배·리뷰 decisions never route down at all — they are the orchestrator's own

(see above).

Parallelism rule of thumb (three independent sources converge on this): **parallel reads are

safe, parallel writes are dangerous**. Fan out freely for research/search/review; keep writes

sequential or isolated (worktree) so two workers never make conflicting implicit decisions in

the same files.

## External executors — the lane outside the harness

This lane buys **capacity, not quality.** It is not a fourth rank below Sonnet — the ranking above

is by judgment, and an outside CLI has not earned a place in it. What it can hold is work whose

**quality a command decides**, the only case where "cheaper" doesn't also mean "worse." Choosing it

because some other vendor is supposedly better inverts this policy's quality-over-cost premise.

**All five predicates must hold; any one false closes the lane.** Each is a question you can answer

right now, not a "use it if it helps."

| # | Predicate | How you answer it now |

|---|---|---|

| **P1** | No judgment is left | The routing question above, unchanged — *"새 판단이 남아 있는가?"* 남아 있으면 닫힌다 |

| **P2** | Passing is machine-decided | Write the pass command on one line, right now. Can't? Closed |

| **P3** | The output gates nothing | It gates no merge, no release, no decision until in-harness cross-verification clears it |

| **P4** | The repo may go to that provider | The first-use approval below is done, and this file set is inside what was approved |

| **P5** | It is **not the CLI you are running on**, and it can use a shell | Delegating to yourself is not a round trip; with no shell, this lane doesn't exist for you |

Even with all five true, **the in-harness repetitive lane is still the default.** Go outside when

mechanical work is eating capacity a judgment lane needs — and reach for the fewest tools that

answer the task, not every tool installed.

**First use in a repository is the user's call, not yours.** Routing implementation to an external

CLI puts this repository's code into another vendor's session — a disclosure none of the in-harness

lanes make. Before the first such delegation in a project, say which tool, which provider its own

config resolves to, which files the worker may touch, and what comes back; then wait. After that one

approval, routing inside the predicates above is yours. Ask again when the boundary moves — a

different tool, or files outside what was approved.

**Tool missing, auth expired, provider refused → step down a lane and report what you could not

use.** Never install it, never log in for them, and never quietly substitute a different provider:

the user knows which tool answered, so a silent swap makes your report false. Recognizing each

failure — and the exact wording for it — belongs to [[external-model-consult]]; where that skill

isn't installed, only the conclusion survives: stop and ask.

**This lane does not choose models.** The tool runs whatever its own config resolves to, and you

report what answered. A model id written down here goes stale and pins the user to a retired model.

**Call the tool's non-interactive mode from the shell.** Read the subcommand off `--help` rather

than typing one from memory, and stop and report if it isn't there. Writes stay isolated (worktree

or equivalent) — the parallel-write rule above holds for outside workers too.

The delegation prompt spec and the file-handoff contract below apply here unchanged: an outside

worker is still a worker.

## Effort floors — and the inheritance gotcha

Effort tiers: `low` < `medium` < `high` < `xhigh` < `max`. Fable 5, Sonnet 5, and Opus 4.8/4.7

support all five; on models without `xhigh` the request silently falls back to the nearest

lower level — check the model before assuming the floor holds.

**The gotcha that breaks this policy silently:** the Agent/Task tool accepts a per-invocation

`model`, but **not a per-invocation `effort`** — a spawned agent inherits the session effort

unless its definition says otherwise. Session default is `high`, so a plain

`Agent(model: "opus")` runs at `high`, **below the xhigh floor**, with no warning. Enforce the

floor through one of these three paths:

1. **Pre-defined agent roles** — `.claude/agents/<role>.md` frontmatter pins both knobs.

This is the durable path for recurring roles:

```yaml

---

name: verifier

description: Fresh-context V&V per model-orchestration policy

model: opus

effort: xhigh

---

```

2. **Workflow scripts** — `agent(prompt, {model: "opus", effort: "xhigh"})` supports both

per call. Use for scripted fan-outs.

3. **Session inheritance** — if the session already runs at `xhigh` (e.g. `/effort xhigh` or

ultracode), a bare `Agent(model: "opus")` inherits a compliant level. Verify with

`/effort`; don't assume.

One environment caveat: `CLAUDE_CODE_SUBAGENT_MODEL` outranks every per-invocation and

frontmatter model choice. If delegation models look wrong, check that env var first.

## Delegation prompt spec

Scale worker count to the task, stated up front in your own plan: trivial lookup → no agent at

all (do it directly); bounded question → one agent; genuinely independent axes → one agent per

axis. Over-spawning is a documented failure mode, and multi-agent runs cost ~15× a plain chat

turn — delegate when the task's value justifies it, not by reflex.

## Worker lifecycle — 다 쓴 에이전트는 닫는다

### Collect results as a file, not as a return message

A worker's final message is not durable transport — long results get truncated silently, and

what was cut is gone. This burned three separate times — most

recently a panel run that lost three reviewers' output — before it was codified as a gate.

The contract: the worker writes its deliverable to a scratchpad/output **file whose path the

orchestrator fixes in the spawn prompt** — collection is a spawn-time decision, because a

truncated reply cannot be retrofit into a file after the fact. The final message then carries

only the file path plus a short summary. Treat any delegation whose prompt names no output

file as not yet dispatched.

## V&V separation

The implementer never verifies its own work — the *instance* that wrote something never judges

it. How that plays out per lane:

- **Sonnet implemented** (반복·단순 구현) → **Opus cross-verifies** — a different model has

different blind spots, which is the cheapest anchoring break available.

- **Opus implemented** (핵심 구현·테스트) → a **fresh Opus instance** verifies: a NEW agent with no

shared history. A verifier that watched the implementation happen inherits the implementer's

mental model and anchors on it — same-session self-review reliably misses the same edge

cases the implementation missed. Instance separation is what makes "Opus builds AND Opus

verifies" coherent.

- **Orchestrator layer on top**: the orchestrator hunts 성능·보안 문제점 in shipped features —

a second, higher-altitude pass that judges what a diff-level verifier doesn't (product fit,

systemic risk). Documents get the same split: Opus authors, the orchestrator reviews via

[[multi-persona-review]].

This pairs with, not replaces, deterministic gates (tests, typecheck, CI) — the verifier

judges what automation can't: spec fit, missed edge cases, design drift.

## Orchestrator handoff (quota exhaustion)

When the top-tier orchestrator's quota runs out mid-project, **Opus @ `max` takes over

orchestration**. There is no reliable automatic path — documented fallback chains explicitly

exclude rate-limit errors, and plan-level auto-switching is undocumented behavior you must not

build on. Hand off manually:

1. Run the [[compaction-handoff]] protocol: persist durable facts to memory, take an atomic

git snapshot (clean tree + open-PR check), emit the fixed-field resume anchor

(current state / verified / what's left / next action).

2. The successor session starts on `opus` at `max` (`/model opus` + `/effort max`), reads the

anchor, and continues as orchestrator under this same policy — setting direction, reviewing,

and hunting problems itself (it can author documents directly too, since it already runs at

the Opus doc-author tier — no separate delegation needed while it stands in).

3. When the top-tier model becomes available again, hand back the same way.

## Anti-patterns

| Anti-pattern | Why it's a violation |

|---|---|

| `Agent(model: "opus")` with session at default effort | Inherits `high` < xhigh floor — use a pinned agent role, Workflow opts, or raise session effort |

| Delegating 방향성 수립 or a final judgment call to a worker | Direction is the orchestrator's own — a delegation prompt can't carry the shaping context |

| Accepting an Opus-authored spec/plan without orchestrator review | Author≠reviewer applies to documents too — run [[multi-persona-review]] before accepting |

| Orchestrator hand-writing full spec/plan drafts itself | Authoring is Opus's lane — brief the direction, delegate the draft, review the result |

| Sonnet on tests, verification, or **core** implementation | Sonnet 의 레인은 반복·단순 구현(확립 패턴 적용)과 읽기 전용 보조까지다 — 테스트·V&V·새 설계 판단은 Opus/Fable 몫 |

| Sonnet 반복 구현물이 Opus 교차검증 없이 머지를 게이트 | 교차검증이 Sonnet 레인의 존립 조건이다 — 검증 없는 반복 구현은 레인 위반과 같다 |

| Effort below floor "to save tokens" | The floors ARE the policy; surface cost concerns to the user instead |

| Implementer verifying its own diff | Anchoring — verification needs fresh context, prefer a different model |

| Two agents writing the same files in parallel | Conflicting implicit decisions; keep writes sequential or worktree-isolated |

| Spawning an agent for what one direct tool call answers | 15× token multiplier for zero value — do trivial work directly |

| Relying on plan-level auto-fallback for continuity | Undocumented behavior; use the manual handoff protocol |

| Finished worker left running after its result is consumed | Subagent panes/windows accumulate (iTerm2 등) and idle pings pollute the session — TaskStop as one motion with consuming the result |

| 외부 실행기에 **테스트 작성·검증**·핵심 구현을 넘김 | 이 레인은 판단 잔여 0 인 일만 받는다 — 무엇을 단언할지 정하는 일을 밖으로 내보내면 외부 산출물을 검사할 기준 자체가 밖에 있게 된다. 형태가 이미 고정된 표에 케이스 한 줄을 복제하는 일은 무엇을 단언할지 정하지 않으므로 여기 해당하지 않는다 |

| 도구가 없어서 조용히 다른 제공자로 갈아타 실행 | 사용자는 어느 도구가 답했는지 알고 있다 — 대체는 보고 대상이지 판단 대상이 아니다 |

| 외부 실행기를 "품질이 더 낫다"는 이유로 고름 | 이 레인이 사는 것은 용량이다. 품질을 근거로 들면 이 정책의 quality-over-cost 전제를 뒤집는 것이다 |

## Quick reference

```

방향성 수립 / 설계·기획 확정 / 작업 분배 / 스펙 리뷰(multi-persona-review) / 기능 개선 / 성능·보안 문제발굴

→ 오케스트레이터(Fable) 직접

스펙 문서 초안(Fable 브리프 기반) / 핵심 구현 / 테스트 작성·실행(E2E 포함) / 코드 리뷰·검증(V&V)

→ opus @ xhigh (또는 max) — pinned role 또는 Workflow opts

반복·단순 구현(확립 패턴 적용) / 리서치 스윕

→ sonnet @ high 이상 — 테스트·검증 투입 금지, 산출물은 Opus 교차검증

결정적 변환 (rename·포맷) → 모델 위임 금지 — sed/grep/스크립트 직접

판단 잔여 0 + 합격을 명령 하나로 판정

→ sonnet 기본 / 다섯 술어 충족 시 외부 실행기 — 최초 1회 사용자 확인, 산출물은 in-harness 교차검증

도구 부재·인증 만료 → 레인을 내리고 무엇을 못 썼는지 보고 — 대신 설치/로그인 금지, 조용한 제공자 교체 금지

위임 완료 → 결과 수거와 동시에 TaskStop (SendMessage 재사용 예정 시만 유지 선언)

Fable 소진 → compaction-handoff → opus @ max 가 오케스트레이터 대행

```