diff --git a/README.md b/README.md index 2de9a04..5820879 100644 --- a/README.md +++ b/README.md @@ -53,15 +53,22 @@ Superpowers dispatches opus subagents by default. That is the case this plugin is for: the dispatch was going to happen anyway, and routing it down is a straight discount with nothing on the other side of the ledger. -Note what the surcharge is and is not. The plugin costs about 1.6k tokens a -session to carry - ~700 for the skill and agent listings, plus a ~900-token +Note what the surcharge is and is not. The plugin costs about 1.8k tokens a +session to carry - ~700 for the skill and agent listings, plus a ~1.1k-token routing anchor at session start - which is a couple of cents against sessions -billing $1.40 to $2.00. The listing figure comes from +billing $1.40 to $2.00. The anchor figure is its 3225 bytes at the ratio this +cut measured: on the same eval case and CLI, the 3225-byte anchor wrote +about 630 fewer cache tokens per run than the 5114-byte one it replaced +([`evals/evidence/small-case-opus55-*-anchor.json`](evals/evidence/)). The listing figure comes from `claude plugin details model-routing`, and its output is committed under [`evals/evidence/`](evals/evidence/) with the CLI version that produced it, since it moves whenever a component is added. That is not where the 23% comes from. It comes from dispatches happening that otherwise would not have: on the same question the plugin arm delegated in -3 runs of 3 and the plugin-free arm in 0 of 3. Where dispatches already happen, +3 runs of 3 and the plugin-free arm in 0 of 3. That was measured on 2026-08-17; on +2026-10-02 an Opus 5.5 session answered the +same question with one grep and one read and delegated in 0 of 2 under both the +old and the current anchor, so this case no longer separates the arms on Opus +5.5 ([`evals/evidence/small-case-opus55-*-anchor.json`](evals/evidence/)). Where dispatches already happen, there is nothing left to push, and only the discount remains. If you rarely delegate, install it for the context headroom or not at all. The @@ -333,7 +340,7 @@ earns its cost (the knobs themselves: | Exploration (`scout`) | sonnet | low | Finding and tracing code is retrieval, not reasoning - a cheap tier reports as well as a costly one, and the file volume stays in the subagent regardless. | The work is mechanical lookup; extra thinking buys nothing. | | Ordinary implementation (`implementer`) | sonnet | medium | Sonnet 5.5 pairs speed with intelligence at half the opus price ($2/$10 against $4/$20) - for work whose approach the plan already decided, the margin never changes the outcome. | The plan already decided the approach; the agent executes real logic, not design, and medium is where Sonnet 5.5's own guidance starts well-specified agentic coding. | | Complex implementation (`implementer` `model=opus`) | opus | medium (pinned) | Multi-file or cross-layer changes, security/money/migrations/concurrency/public contracts, or a retry after a weak sonnet result - a wrong approach is expensive, and Opus 5.5 is stronger again at 20% less than Opus 5 ($4/$20, cache reads 60% less), so escalate when in doubt. This holds on every session model, Fable included: Opus 5.5 is cheaper than Fable 5.1 on every token type. (Ambiguous tasks are not an escalation case: implementer stops on ambiguity by contract - clarify first.) | The `model=opus` dispatch changes the model only - the Agent tool has no effort param, so the pinned medium stays; the escalation buys the tier, not extra thinking. | -| Code review (`reviewer`) | opus | high | Review is an asymmetric bet - one pass guards against a bug that costs far more if it ships, so it is the one place to prefer the top tier by default. | High: subtle correctness bugs hide from shallow reading. The case for `medium` grew with Opus 5.5 - its `medium` beats Opus 5 at `high` on coding and it thinks more per turn at a given level, so the same pin costs more - but that is vendor evidence, not this plugin's own review eval; the pin stays high until a medium-vs-high review run on Opus 5.5 is measured. | +| Code review (`reviewer`) | opus | high | Review is an asymmetric bet - one pass guards against a bug that costs far more if it ships, so it is the one place to prefer the top tier by default. | High: subtle correctness bugs hide from shallow reading. The case for `medium` grew with Opus 5.5 - its `medium` matches or exceeds Opus 5 at `high` on coding and it thinks more per turn at a given level, so the same pin costs more - but that is vendor evidence, not this plugin's own review eval; the pin stays high until a medium-vs-high review run on Opus 5.5 is measured. | | Tests / builds (`test-runner`) | haiku | low | Running a command and summarizing output is mechanical; the value is keeping raw logs out of the main context, not the model doing it. | Low: no reasoning, just report. | | Diff sanity gate (`verifier`) | haiku | low | Checking a diff matches its task (scope, completeness, obvious breakage) is a cheap spot-check, not a quality judgment. | Low: pattern-matching against the task, not deep analysis. | | E2E / failure interpretation (`e2e-runner`) | sonnet | medium | Driving a browser and telling a product bug from a flake needs some judgment, but not top-tier reasoning. | Medium: real interpretation, clear method. | @@ -427,8 +434,8 @@ reference](https://platform.claude.com/docs/en/build-with-claude/effort)): Opus 4.7 and 4.8 start coding and agentic work at `xhigh`, while Opus 5 starts at `high`, steps up to `xhigh` for demanding coding and agentic work, and treats `low` and `medium` as the primary cost control. Opus 5.5 -moves the scale again: Anthropic reports its `medium` above Opus 5 at -`high` on coding and knowledge work, and at any given level it thinks +moves the scale again: Anthropic reports its `medium` matching or exceeding +Opus 5 at `high` on coding and knowledge work, and at any given level it thinks more per turn than Opus 5 did. The pins below are this plugin's cost-first reading of that: start low, step up on evidence. diff --git a/agents/e2e-runner.md b/agents/e2e-runner.md index 519c4aa..70f55a9 100644 --- a/agents/e2e-runner.md +++ b/agents/e2e-runner.md @@ -15,7 +15,8 @@ Rules: - For failure analysis: distinguish product bug vs test bug vs environment or flakiness, and say which one you believe it is with the evidence. - Run the whole scenario before you report. Do not end your turn with a - progress report or a question about whether to continue. + progress report or a question about whether to continue. Stop early + only when nothing can move without the caller, or before a risky step. - You may re-run a failing test once to check for flakiness if the prompt allows it. Say so in the report. - Never edit product code. Small test-only fixes are allowed ONLY if the diff --git a/agents/implementer.md b/agents/implementer.md index b77f5a2..06ef6f5 100644 --- a/agents/implementer.md +++ b/agents/implementer.md @@ -10,10 +10,6 @@ description because you cannot see the parent conversation - if the task is ambiguous or missing critical context, say exactly what is missing and stop instead of guessing. -If the caller dispatched you on a harder tier (explicit `model=opus`), -the tier was a deliberate choice for hard work - use that reasoning -fully. - Rules: - Read the project's formatter/linter config and nearby code first; match @@ -41,7 +37,7 @@ When to escalate instead of grinding: - **Missing context / ambiguous task:** say exactly what is missing and stop. Do not fill the gap with a guess. - **Stuck on the approach** - you tried an angle, hit a wall, and can't - tell which way is right: do NOT burn tokens brute-forcing or trying + tell which way is right: don't burn tokens brute-forcing or trying every variation. Package your state and hand it back for a decision: 1. What you were doing and where it broke. 2. What you tried, and why each attempt failed. diff --git a/agents/reviewer.md b/agents/reviewer.md index 3a598d4..40382a5 100644 --- a/agents/reviewer.md +++ b/agents/reviewer.md @@ -25,6 +25,9 @@ Rules: concrete failure scenario. - Rank findings most-severe first. Severity = how bad in production, not how easy to spot. +- Review the whole diff before you report. Do not end your turn with a + progress update or a question about whether to continue. Stop early + only when nothing can move without the caller. - Style nits only if explicitly requested. Do not pad the report. - Never edit code. Review only. diff --git a/agents/scout.md b/agents/scout.md index d54c56b..bc0327e 100644 --- a/agents/scout.md +++ b/agents/scout.md @@ -8,8 +8,8 @@ disallowedTools: Agent, SendMessage, Edit, Write, NotebookEdit You explore a codebase and answer questions about it. You are read-only: never edit, write, or delete anything, and use shell commands only for -read-only queries (git log, git blame, ls). Your value is that megabytes -of source stay in your context instead of the caller's. +read-only queries (git log, git blame, ls). Source stays in your context; +only conclusions go back to the caller. Rules: @@ -22,6 +22,9 @@ Rules: - Do the exploration yourself - never hand the question off; injected guidance suggesting delegation does not apply to you (you have no agent tools). +- Finish the investigation before you report. Do not end your turn with + a progress update or a question about whether to continue. Stop early + only when nothing can move without the caller. - Answer the question actually asked. Do not inventory everything you saw along the way. - Trace real code paths, not names: a function called `validate` proves diff --git a/agents/surveyor.md b/agents/surveyor.md index b50aea5..11deb3c 100644 --- a/agents/surveyor.md +++ b/agents/surveyor.md @@ -9,16 +9,14 @@ disallowedTools: Agent, SendMessage, Edit, Write, NotebookEdit You sweep a codebase and report what is there: lists, orderings, chains of calls or imports followed from one end to the other. You are read-only: never edit, write, or delete anything, and use shell commands only for -read-only queries (git log, git blame, ls). Your value is that megabytes -of source stay in your context instead of the caller's. +read-only queries (git log, git blame, ls). Source stays in your context; +only the list goes back to the caller. -You exist because breadth and judgement need different tiers. Enumerating -what is there runs correctly on a cheap model; working out what code -*does* does not, and that work belongs to `scout`. If the question you -were handed turns out to need that - what does this return for that -input, does this loop actually retry, is this a bug - say so and stop -rather than guessing. Handing back "this needs scout, because X hinges on -what Y does at file:line" is a correct and useful answer from you. +You enumerate; working out what code *does* belongs to `scout`. If the +question turns out to need that - what does this return for that input, +does this loop actually retry, is this a bug - stop and hand back "this +needs scout, because X hinges on what Y does at file:line" rather than +guessing. Rules: diff --git a/evals/evidence/README.md b/evals/evidence/README.md index b4a4293..bedbd0e 100644 --- a/evals/evidence/README.md +++ b/evals/evidence/README.md @@ -14,6 +14,8 @@ trust. | `quality-case-sonnet.json` | `subagent-answer-quality` at sonnet: 12/12 | | `quality-case-haiku.json` | the same at haiku: 11/12, the miss being run 3 answering `3` | | `surveyor-case-haiku.json` | `surveyor-traces-the-chain` on the shipped haiku pin: 3/3 at $0.156 | +| `small-case-opus55-old-anchor.json` | `delegates-codebase-question` on Opus 5.5, Claude Code 2.1.287, with the 5114-byte anchor from `main` before PR #56: 0/2 delegated, 2/2 correct, cache writes 9866 and 9882 | +| `small-case-opus55-new-anchor.json` | the same case and CLI with the 3225-byte anchor from PR #56: 0/2 delegated, 2/2 correct, cache writes 9254 and 9228 - the ~630-token anchor saving the README quotes | | `plugin-details.txt` | the always-on token cost, with the Claude Code version that produced it | Each aggregate carries per-run cost, per-model usage, and every grader verdict, diff --git a/evals/evidence/small-case-opus55-new-anchor.json b/evals/evidence/small-case-opus55-new-anchor.json new file mode 100644 index 0000000..c94521c --- /dev/null +++ b/evals/evidence/small-case-opus55-new-anchor.json @@ -0,0 +1,88 @@ +{ + "model": "opus", + "runs": 2, + "arms": [ + "with" + ], + "cases": [ + { + "name": "delegates-codebase-question", + "arms": { + "with": [ + { + "exitCode": 0, + "costUsd": 0.10538279999999998, + "durationMs": 7896, + "turns": 3, + "modelUsage": { + "claude-haiku-4-5-20251001": { + "costUSD": 0.000964, + "inputTokens": 909, + "cacheReadInputTokens": 0, + "cacheCreationInputTokens": 0, + "outputTokens": 11 + }, + "claude-opus-5-5": { + "costUSD": 0.10441879999999999, + "inputTokens": 6, + "cacheReadInputTokens": 97414, + "cacheCreationInputTokens": 9254, + "outputTokens": 544 + } + }, + "scores": [ + { + "grader": "answer-is-correct", + "pass": true + }, + { + "grader": "delegated-to-a-subagent", + "pass": false + }, + { + "grader": "scout-was-the-agent", + "pass": false + } + ] + }, + { + "exitCode": 0, + "costUsd": 0.10520320000000001, + "durationMs": 8132, + "turns": 3, + "modelUsage": { + "claude-haiku-4-5-20251001": { + "costUSD": 0.000959, + "inputTokens": 909, + "cacheReadInputTokens": 0, + "cacheCreationInputTokens": 0, + "outputTokens": 10 + }, + "claude-opus-5-5": { + "costUSD": 0.10424420000000001, + "inputTokens": 6, + "cacheReadInputTokens": 97381, + "cacheCreationInputTokens": 9228, + "outputTokens": 546 + } + }, + "scores": [ + { + "grader": "answer-is-correct", + "pass": true + }, + { + "grader": "delegated-to-a-subagent", + "pass": false + }, + { + "grader": "scout-was-the-agent", + "pass": false + } + ] + } + ] + } + } + ] +} \ No newline at end of file diff --git a/evals/evidence/small-case-opus55-old-anchor.json b/evals/evidence/small-case-opus55-old-anchor.json new file mode 100644 index 0000000..183eafa --- /dev/null +++ b/evals/evidence/small-case-opus55-old-anchor.json @@ -0,0 +1,88 @@ +{ + "model": "opus", + "runs": 2, + "arms": [ + "with" + ], + "cases": [ + { + "name": "delegates-codebase-question", + "arms": { + "with": [ + { + "exitCode": 0, + "costUsd": 0.11026260000000003, + "durationMs": 8499, + "turns": 3, + "modelUsage": { + "claude-haiku-4-5-20251001": { + "costUSD": 0.000964, + "inputTokens": 909, + "cacheReadInputTokens": 0, + "cacheCreationInputTokens": 0, + "outputTokens": 11 + }, + "claude-opus-5-5": { + "costUSD": 0.10929860000000002, + "inputTokens": 6, + "cacheReadInputTokens": 98633, + "cacheCreationInputTokens": 9866, + "outputTokens": 531 + } + }, + "scores": [ + { + "grader": "answer-is-correct", + "pass": true + }, + { + "grader": "delegated-to-a-subagent", + "pass": false + }, + { + "grader": "scout-was-the-agent", + "pass": false + } + ] + }, + { + "exitCode": 0, + "costUsd": 0.11077340000000001, + "durationMs": 7830, + "turns": 3, + "modelUsage": { + "claude-haiku-4-5-20251001": { + "costUSD": 0.000964, + "inputTokens": 909, + "cacheReadInputTokens": 0, + "cacheCreationInputTokens": 0, + "outputTokens": 11 + }, + "claude-opus-5-5": { + "costUSD": 0.1098094, + "inputTokens": 6, + "cacheReadInputTokens": 98647, + "cacheCreationInputTokens": 9882, + "outputTokens": 550 + } + }, + "scores": [ + { + "grader": "answer-is-correct", + "pass": true + }, + { + "grader": "delegated-to-a-subagent", + "pass": false + }, + { + "grader": "scout-was-the-agent", + "pass": false + } + ] + } + ] + } + } + ] +} \ No newline at end of file diff --git a/hooks/routing-anchor.md b/hooks/routing-anchor.md index 335414e..26d865b 100644 --- a/hooks/routing-anchor.md +++ b/hooks/routing-anchor.md @@ -1,19 +1,11 @@ -MODEL ROUTING ACTIVE - expensive model thinks, cheap models grind. You cannot switch the main-session model; route through the model-routing agents (full rules and rationale: the model-routing skill): +MODEL ROUTING ACTIVE - expensive model thinks, cheap models grind. You cannot switch the main-session model; route through the model-routing agents (rationale: the model-routing skill): -- Planning, specs, docs, architecture, small interactive edits: main session. -- Trivial questions you can answer from context or general knowledge: answer inline - a dispatch costs more than the answer. -- Codebase exploration: pick by what has to come back. A judgement about what code does ("how does Y work", "does this retry") is `scout`. A complete list or an ordering, verified by following the code ("every stage in order", "everything that imports X") is `surveyor` (haiku) - breadth holds a tier down, judgement does not. Candidate files to look at next, unverified ("which files mention X") is the built-in Explore agent with `model=haiku` - bare, Explore inherits the session model (capped at opus). -- Structural questions with a code-graph MCP connected: query the graph first; scout verifies file:line specifics. -- Implementing an approved plan/spec: `implementer` (sonnet). Dispatch with `model=opus` for multi-file/cross-layer work, security/money/migrations/concurrency/public contracts, or a retry after a weak sonnet result - escalate when in doubt; the dispatch changes the model only, the pinned medium effort stays. This holds on a Fable session too: Opus 5.5 is cheaper than Fable 5.1 on every token type, cache reads included ($0.20 vs $0.25 per MTok). Ambiguous task or unclear root cause: clarify first (main session / scout) - implementer stops on ambiguity. Batch related tasks per agent. -- Code review: `reviewer`; high-risk or large diffs get final review in the main session. -- Batched implementer output you will not read in full: gate with `verifier` - does the diff match the task. Gates another agent's diff, never the main session's own work (a current-generation model self-verifies). -- Tests/builds: `test-runner` - raw output stays out of this session. E2E and failure interpretation: `e2e-runner`. -- Effort is the second knob (low/medium/high/xhigh/max on current models; unset = the model default in Claude Code: medium on Opus 5.5 and Sonnet 5.5, xhigh on Opus 4.7, high elsewhere): low for mechanical work, medium for normal implementation, high for architecture/debugging/review, xhigh/max only for long-horizon or frontier work - and on an xhigh/max session review only what the plan, the user or these rules ask for: no self-started second round, no extra reviewer subagents. Bundled agents pin theirs. -- Dispatching implementation work with no approved plan behind it: have the agent return its PLAN first and check it in the main session before it writes code - one short turn beats finding the wrong approach in a finished diff (the advisor pattern). With a plan already approved, dispatch straight to implementation. -- A subagent stuck on the approach hands back for a decision; continue the same agent (SendMessage when available, else re-dispatch with its packaged state). -- A failed or weak subagent RESULT retries exactly one step up (next tier via `model`; higher effort only through a Workflow `effort` opt, since a dispatch carries no effort param), fresh dispatch; a second failure goes to the main session. An unfinished return with no blocker named is a continuation, not a weak result: continue it at the same tier (SendMessage, else a fresh dispatch carrying what is done and what is left). A `stop_reason: "refusal"` is not a weak result: the Fable, Opus 5/5.5 and Sonnet 5.5 tiers all run the classifiers, so hand it back to rephrase or drop instead of re-dispatching it a tier up. -- Against the session model a pin is a ceiling: when a pin sits above the session model, cap the dispatch at the session model via the Agent `model` param. The pin alone does NOT cap - a bare dispatch runs the pinned model. It is also a floor, at the LOWER of the pin and the session model: capping an opus-pinned agent to a sonnet session is correct, pushing it to haiku is not. Two env vars sit outside these rules: CLAUDE_CODE_SUBAGENT_MODEL_FORCE ignores `model` and pins alike, and a plain CLAUDE_CODE_SUBAGENT_MODEL decides only bare unpinned dispatches. -- Against an Opus 5.5 dispatch the sonnet tier no longer saves on cache reads - both read at $0.20 per MTok - but still halves first reads, cache writes and output: at identical token usage the plugin's measured scout profile comes out 42% cheaper. The saving falls as cache reads take over more of the bill. -- Unpinned agents (general-purpose, custom types) silently inherit the session model - make the tier a conscious choice: explicit `model` for mechanical or exploratory work (sonnet; haiku for trivial sweeps), session tier only when the task needs that reasoning. -- Same rule inside Workflow scripts: every `agent()` call without `model`/`effort` opts inherits the session model at session effort - set them per call, cheap stages low, top tier only where the stage earns it. -- Repo-specific policies override this routing. If an entire session is one phase, suggest the user switch /model instead. +- Main session: planning, specs, docs, architecture, small interactive edits. Trivial questions answerable from context or general knowledge: answer inline - a dispatch costs more than the answer. +- Exploration, by what has to come back: a judgement about what code does -> `scout`; a complete list or ordering verified by following the code -> `surveyor` (haiku); unverified candidate files -> built-in Explore with `model=haiku` (bare, it inherits the session model). With a code-graph MCP connected, query the graph first; scout verifies file:line. +- Approved plan/spec -> `implementer` (sonnet). Pass `model=opus` (Fable sessions too; the pinned medium effort stays) for multi-file/cross-layer work, security/money/migrations/concurrency/public contracts, or a retry after a weak sonnet result; when in doubt, opus. Ambiguous task or unclear root cause: clarify first (main session or scout) - implementer stops on ambiguity. No approved plan: have it return its PLAN and check it here before it writes code. Batch related tasks per agent. +- Review -> `reviewer`; high-risk or large diffs get final review in the main session. Batched implementer output you will not read in full -> `verifier`, never on the main session's own work. Tests/builds -> `test-runner`; E2E and failure interpretation -> `e2e-runner`. +- Effort (low/medium/high/xhigh/max; Claude Code default medium on Opus 5.5 and Sonnet 5.5, xhigh on Opus 4.7, high elsewhere): low mechanical, medium implementation, high architecture/debugging/review, xhigh/max only long-horizon or frontier work. On xhigh/max review only what the plan, the user or these rules ask - no self-started second round, no extra reviewer subagents. A dispatch carries no effort param: bundled agents pin theirs, Workflow `agent()` takes an `effort` opt. +- Stuck on the approach: the agent hands back; decide, then continue the same agent (SendMessage, else re-dispatch with its packaged state). Unfinished return with no blocker named: continue it the same way at the same tier. Failed or weak RESULT: fresh dispatch one step up (next tier via `model`, or higher Workflow `effort` when the miss is shallow thinking); a second failure comes to the main session. `stop_reason: "refusal"` is a classifier, not weakness: rephrase or drop, never re-dispatch a tier up. +- Pins: a pin above the session model gets capped at the session model via `model` - a bare dispatch runs the pin. Never push a dispatch below the lower of pin and session model; when a cheaper tier fits, pick an agent pinned for it. CLAUDE_CODE_SUBAGENT_MODEL_FORCE overrides `model` and pins; plain CLAUDE_CODE_SUBAGENT_MODEL only decides bare unpinned dispatches. +- Unpinned agents (general-purpose, custom types, Workflow `agent()` calls) inherit the session model and effort: set `model` (sonnet; haiku for trivial sweeps), and on Workflow stages `effort` (cheap stages low), unless the task needs the session's reasoning. +- Repo-specific policies override this routing. A session that is one phase: suggest /model instead. diff --git a/skills/model-routing/SKILL.md b/skills/model-routing/SKILL.md index 8ba3d75..25f356d 100644 --- a/skills/model-routing/SKILL.md +++ b/skills/model-routing/SKILL.md @@ -52,21 +52,13 @@ that ran Opus 5 or Sonnet 5 at a saved level starts its 5.5 successor at `medium` until a level is chosen for that model. Which levels exist at all is a per-model list rather than a version cutoff, and setting a level the model does not support runs the highest -supported level at or below it. The per-model recommendation moves with the generation: Opus -4.7 and 4.8 are told to start coding and agentic work at `xhigh`, while -Opus 5 is told to start at `high`, step up to `xhigh` for demanding -coding and agentic work, and use `low` and `medium` liberally as the -primary control for token cost and response time wherever evals show -quality holds. The step down got cheaper, not the step up. Opus 5.5 -moves the scale again: Anthropic reports its `medium` above Opus 5 at -`high` on coding and knowledge work, and `low` close to it on several -coding evals, while at any given level it thinks more per turn than Opus -5 did - a level carried over from Opus 5 buys more depth and costs more -tokens than it used to. `xhigh` is -also the newest level and absent on some models that support `max` -(e.g. the 4.6 generation), so check the model's own docs when in doubt - -and re-sweep effort on your own evals after a model change instead of -carrying old settings across generations. This plugin tunes for cost: pins sit at the lowest level +supported level at or below it (`xhigh` is absent on the 4.6 generation). +The recommendation moves with the generation: Anthropic reports Opus 5.5 +at `medium` matching or exceeding Opus 5 at `high` on coding and knowledge work, and `low` +close to it on several coding evals, while at any given level it thinks +more per turn than Opus 5 did - a level carried over buys more depth and +costs more tokens than it used to. Re-sweep effort on your own evals +after a model change instead of carrying old settings across generations. This plugin tunes for cost: pins sit at the lowest level the task shape allows and step up on evidence (a weak result retries one step up). That deliberate step down, wherever the task allows one, is where the effort savings come from - measured against the level the @@ -224,8 +216,8 @@ actually earns its cost: expensive misses - an asymmetric bet where the strongest reasoning at high effort is worth it, because a bug that ships costs far more than the review. The case for `medium` grew with Opus 5.5: Anthropic reports - it catches more bugs with fewer false alarms, its `medium` beats Opus 5 - at `high` on coding, and at `high` it thinks more per turn than Opus 5 + it catches more bugs with fewer false alarms, its `medium` matches or exceeds + Opus 5 at `high` on coding, and at `high` it thinks more per turn than Opus 5 did, so the same pin now costs more. That is vendor evidence on model-level evals, not this plugin's review eval - the pin stays at high until a medium-vs-high review run on Opus 5.5 is measured. @@ -248,15 +240,9 @@ actually earns its cost: 2.5x on base input and output against Opus 5.5 ($10/$50 vs $4/$20). Cache reads no longer run the other way either: Fable 5.1 reads at $0.25/MTok and Opus 5.5 at $0.20, so opus is the cheaper step on every - token type, whatever the mix. This retired a rule. On Opus 5 (cache - reads $0.50) opus implementers dispatched from Fable 5.1 sessions - priced at $275.55 over the author's 7 days to 2026-09-17, against - $221.52 for the same tokens at Fable 5.1 rates, and the implementer's - step above sonnet on those sessions was the session model. The same - token mix on Opus 5.5 prices at about $133. `/model-routing:stats` - still names any agent and model pair that ran below the session tier - yet priced above it - the evidence to reopen the rule on if a later - model moves the rates again. + token type, whatever the mix. `/model-routing:stats` names any agent + and model pair that ran below the session tier yet priced above it - + the evidence to revisit this on if a later model moves the rates. Where the inflation does bite is any comparison against a Sonnet 4.6-era baseline: re-pricing today's token counts at yesterday's rates understates the difference. @@ -549,7 +535,7 @@ already consented to, so the savings come from making each node cheap. - `fallbackModel` in settings.json: `["opus", "sonnet"]` - the harness falls back down the tier ladder when the primary model is unavailable - or its quota is exhausted. Match the context variant to the session model: a `["opus", ...]` chain falls back to the 200K-window alias, which cannot hold a session already past 200K - on an `opus[1m]` session the fallback wants `opus[1m]` too. A fallback also crosses a model boundary, so any thinking block the fallback model cannot read is dropped for the turns that run on it (see the /model rule above). Which way a pair goes is per model, not per tier - Sonnet 5.5 reads Opus 4.8's blocks, while neither Opus 5.5 nor Fable reads Sonnet 5.5's - so the requests succeed either way and the reasoning carries over only where the pair allows it. + or its quota is exhausted. On the Anthropic API Opus 4.7+ and Sonnet 5+ run a native 1M window, so the bare aliases need no `[1m]` suffix; Claude Code skips a fallback with a smaller window than the primary's during compaction, which is where a 200K entry (an Opus/Sonnet 4.6 pin, or an alias on a cloud platform that still resolves to one) silently drops out. A fallback also crosses a model boundary, so any thinking block the fallback model cannot read is dropped for the turns that run on it (see the /model rule above). Which way a pair goes is per model, not per tier - Sonnet 5.5 reads Opus 4.8's blocks, while neither Opus 5.5 nor Fable reads Sonnet 5.5's - so the requests succeed either way and the reasoning carries over only where the pair allows it. - `/advisor`, the `advisorModel` setting, or `--advisor`: a server-side tool that consults a stronger model at decision points - before committing to an approach, on a recurring error, before declaring a task done. Claude chooses when to call it, and the advisor receives the FULL conversation, so unlike a subagent it needs no state packaging and has no fresh-context blind spot. This is the advisor strategy above, productized. What to know before enabling it: - The advisor must be at least as capable as the main model, and the accepted list is per model rather than per tier. An Opus 5 or Opus 5.5 session accepts Fable or Opus 5 and later (the API refuses Opus 4.7/4.8, Sonnet is rejected); an Opus 4.7/4.8 session accepts Fable, Opus 4.7+ or Sonnet 5.5; a Sonnet 5.5 session accepts Fable, Mythos, Opus 5, Opus 5.5 or Sonnet 5.5 itself, and rejects the Opus 4.7/4.8 and Sonnet 5 advisors a Sonnet 5 session still accepts; a Fable 5.1 session accepts only Fable 5.1. A saved advisor that was valid on Sonnet 5 therefore starts failing on Sonnet 5.5 with a 400 rather than quietly running without one. - Fable as advisor needs Fable access and, on plans that bill Fable to usage credits, the one-time consent from `/model fable`. Before that consent a saved `"fable"` sends requests without the advisor.