Source: wiki synthesis: Advisor Strategy, Extended Thinking, Opus 4.7 Best Practices, Claude Prompting Best Practices, Hermes Productivity Workflows, SEO Content, Marketing Automation Use Cases + raw/Your_AI_Model_is_Probably_Wrong_for_This_Job.md (Nate B Jones, “AI News & Strategy Daily,” 2026-07-01) + raw/You_Can_t_Compete_on_Cheap_Models_Anymore.md (Nate B Jones, “AI News & Strategy Daily,” 2026-07-05) + raw/reddit-1uofi2s.md (r/ClaudeAI, u/LastNameOn, “storybloq’s approach to using fable efficiently,” 2026-07-05) + raw/reddit-1uymb54.md (r/ClaudeAI, u/ShayaLeSpark, “Claude’s top model cost 10,” 2026-07-17) + raw/reddit-1v1qak5.md (r/ClaudeAI, Sonnet 5 Sept 1 2026 pricing-change report, 2026-07-20) + raw/x-account-claudeai-2078302415804379218.md (first-party @claudeai Fable 5 plan-tiering, 2026-07-20) + raw/newsletter-epoch-ai-f0a9e365ff.md (Epoch AI, “the plunging price of thought”, 2026-09-28) + raw/DHH_-Future_of_Programming_AI_Agentic_Engineering_Vibe_Coding_Linux_Lex_Fridman_Podcast_501.md (DHH on Lex Fridman Podcast #501) + raw/Infinite_Slop-The_End_of_Apps_Meet_the_Agentic_OS_Built_for_Your_Phone.md (Leo Laporte, Intelligent Machines ep. 886) + raw/The_AI_Model_Tier_List.md (Nathaniel Whittemore, The AI Daily Brief) + raw/AI_News-_OpenAI_Made_a_Massive_Move_Against_NVIDIA.md (Matt Wolfe, Vercel request-count caveat). 2026-10-27: the October 2026 additions section cites its podcast sources inline. The October 2026 pricing update cites ai-research/anthropic-claude-haiku-5-5-announcement-2026-10-27.md (Haiku 5.5 launch post) and raw/anthropic-watch-claude-code-tag-v2-1-296.md (Claude Code v2.1.296 release notes).
Four independent levers shape the cost/intelligence profile of an agent workflow. Most teams treat “more intelligence” as one dial — pick a bigger model, pay more. That misses the real optimization surface. Three of the four — Effort, Adaptive Thinking, and Advisor — tune behavior once you’ve already committed to Claude; they compose multiplicatively, and the right combination depends on the workload shape, not the prestige of the model name. The fourth, Model Family Choice, is the prior, vendor-agnostic decision of which model to reach for before you’re inside Claude’s parameter space at all — see Lever 4 below.^[inferred: the “prior, vendor-agnostic” framing and its compositional relationship to Levers 1-3 is this connector’s synthesis, not stated verbatim in either source]
The four levers
Lever 1 — Effort (per-call intelligence budget)
The effort parameter (see Opus 4.7 Best Practices) trades capability for speed and cost at each call:
| Level | Use when |
|---|---|
max | Genuinely hard problems; diminishing returns; prone to overthinking |
xhigh (new default) | Most coding and agentic uses — Anthropic’s recommended starting point |
high | Balance intelligence and cost; minimum for intelligence-sensitive work |
medium | Cost-sensitive with intelligence tradeoff |
low | Short scoped tasks, latency-sensitive |
Opus 4.7 respects effort strictly — low and medium now scope work to what was explicitly asked. Under-thinking risk at low for moderately complex tasks, so raise effort rather than prompt around it.
Lever 2 — Adaptive Thinking (per-step reasoning depth)
Adaptive thinking (thinking: {type: "adaptive"}) lets the model decide at each step whether to think and how much (see Extended Thinking for the full reference). On Opus 4.7 it’s the only supported mode — manual budget_tokens returns 400.
Adaptive is the right default for:
- Autonomous multi-step agents
- Long-horizon coding sessions
- Bimodal workloads (mix of easy + hard tasks)
Display modes compound: display: "omitted" reduces streaming latency without reducing cost. Guidance: pick adaptive + explicit effort + display mode suited to your UX surface.
Lever 3 — Advisor (on-demand intelligence boost)
The advisor_20260301 tool (see Advisor Strategy) inverts the typical sub-agent pattern. A cheap executor (Sonnet, Haiku) drives the loop and consults Opus upward only when stuck. One API call, max_uses budget, advisor never calls tools or produces user output.
Result: Anthropic measured Sonnet + Opus advisor at +2.7pp on SWE-bench with 11.9% lower cost than Sonnet solo. Haiku + Opus advisor doubles Haiku’s BrowseComp score at 85% less than Sonnet solo.
Lever 4 — Model Family Choice (the prior, vendor-agnostic question)
Added 2026-07-02. Framed against the backdrop of the July 2026 Fable 5 outage (see Mythos 5 Federal Shutdown): the companies that rode out the 18-day gap without disruption were the ones that never tied their work to a single model, because they owned the harness and could route elsewhere.
Levers 1-3 above tune a model’s behavior once you’ve already committed to Claude. Lever 4 is the decision that comes before that: which model family to reach for at all. This is where cost and intelligence properly diverge into two different tools, not two settings on one tool.
Daily driver vs. cheap workhorse.
- A daily driver needs to be good across a wide range of use cases — it’s the model you reach for before the task is well-understood.
- A cheap workhorse earns its place when the job is familiar, repeatable, and easy to understand.
Validate a daily-driver candidate by testing it directly against the inputs you actually care about (spreadsheets, PowerPoints, docs, code) — people tend to underestimate a task’s real complexity until they’ve actually tried it on the model.
Center-of-distribution work vs. Fable-style problem — a finer-grained version of the same split.^[inferred: “finer-grained version of the same split” is this connector’s framing; both underlying distinctions are the source’s]
- Center-of-distribution work is routine, familiar-shaped: a normal PowerPoint, a landing-page draft, a meeting summary, a CRM cleanup, code with a shape the model has seen many times before (“here’s the file, just work on it”). This is most of what most people produce most days. GLM-5.2 is named directly as handling this well and cheaply — “in some cases better than Claude.”
- A Fable-style problem is the opposite: the hard part isn’t producing a familiar artifact cheaply, it’s understanding what a new capability means — across video, physics, character intent, legal exposure, business strategy. Here you want the broadest, strongest, “weirdest generalization” frontier model available, plus a harness that keeps the context together — cost should not be the optimization target.
Named migrations — directional evidence, not settled proof. The source names specific companies routing off single-vendor frontier defaults for center-of-distribution work. These are stated as fact in the video without a cited primary source (company blog, filing, etc.) — treat as directional evidence of an industry pattern, not independently verified case studies:
- Lindy — moving serious traffic to DeepSeek to cut costs.
- Cursor — built Composer on, and has moved toward, Kimi/Kimmy-class pretrained models for cost savings.
- Coinbase — increasing total token usage while cutting costs via smart routing to open-source routers (GLM, Kimmy).
- Shopify and Airbnb — using Qwen-style routing because their query mix routes there effectively.
- Microsoft — testing a DeepSeek architecture internally.
None of this argues against frontier models generally — the source is explicit that Claude and Codex/ChatGPT remain the right call once a task requires “generalized intelligence”: “you cannot substitute for Claude or for ChatGPT… when you are tackling a tough generalized task.” It’s evidence that sophisticated engineering orgs are actively splitting workload across model families by task difficulty, not defaulting to one model everywhere.
Harness quality is a lever independent of raw intelligence. A model’s benchmark intelligence and how easy it is to get work in and out of it are two different axes. The source’s example: Gemini is “a solid model without a great harness” — strong underlying intelligence, suppressed practical utility because getting work in and out is unnecessarily difficult. This is offered as the reason frontier and open-weight labs alike are now investing in harness quality as a competitive axis distinct from model quality — Z.ai shipped a dedicated harness for GLM 5.2 for this reason, citing the success Claude Code and Codex have had with their own harnesses. See Maintain the Harness, Don’t Pile On Tools (same author, companion thesis: the harness — not the model underneath it — is the durable, ownable layer). Practically, this means evaluating a daily-driver candidate’s harness alongside its model card, not instead of it.^[inferred: the practical takeaway sentence extends the source’s harness point into an evaluation instruction]
Five decision rules (source’s “rules of the road”):
- Don’t just copy someone else’s model choice (including this source’s own picks) — the right choice is a function of your workload, not a leaderboard.
- Ask how hard the work actually is, not how much of it there is. Volume doesn’t imply difficulty.
- Know how you’ll judge output quality before committing — evals plus a manual “sniff test.” See Picking the Right Model — Building Evals for Model Selection for a full build-your-own-eval method.
- Don’t let model choice become its own job — make sure whatever model is available to you is applied without the choosing itself turning into extra work.
- Don’t pick too many models. The source names roughly half a dozen across the video (Claude, ChatGPT, GLM, Qwen, Kimi, DeepSeek) but is explicit that “it is likely that you don’t need that many to get your work done” — pick the minimum viable set for your actual workload rather than a specific target count.^[inferred: no specific number of models is stated in the source; “minimum viable set” is this connector’s operationalization of “you don’t need that many”]
Lever 4 gates the other three: once a model family is chosen as the daily driver, Levers 1-3 above tune behavior within it. If the workload is center-of-distribution and the chosen family is an open-weight model like GLM 5.2, the Effort / Adaptive-Thinking / Advisor mechanics documented above (which are Anthropic-API-specific) don’t directly transfer — each model family has its own analogous tuning surface, out of scope for this article.^[inferred: this closing synthesis paragraph connects Lever 4 to Levers 1-3; not stated in either source]
Lever 4, continued — the imagination test (concrete evidence for the split above)
Added 2026-07-05, from a second Nate B Jones video that names the mechanism behind the center-of-distribution/Fable-style split above: when execution gets cheap, value doesn’t disappear — it moves to whoever can imagine the task worth asking for.
Hashimoto’s two-part experiment. HashiCorp co-founder Mitchell Hashimoto ran Fable 5 against cheaper models (a sub-1.50, Fable 5 cost 40, and reached a level of performance Hashimoto — one of the field’s most respected engineers — said he couldn’t have hit on his own.
Why the first half tied, and the second half didn’t. “Implement this feature” is work everyone already knows how to ask for — prompts are shared, playbooks are public, and when a million people run the same task through the same tools, results converge. That’s a fact about the task, not the models: familiar, already-imagined work is exactly where cheap and frontier models have converged, and it’s genuinely fine to route it cheap. Hashimoto’s 40 job still needed 2 hours of frontier-model execution to become real), but imagination is what sets the multiplier on top of it.
Two analogies for the same divergence:
- Blackberry vs. Apple — both built smartphones with comparable execution muscle (Blackberry’s keyboard, email, and security were best-in-class). Blackberry lost not on execution but because it executed brilliantly inside a category Apple had already re-imagined. Comparable execution; imagination set a 100x value gap.
- Factory electrification — the technology worked on day one, but the productivity payoff took decades because factories kept the steam-era layout: every machine stayed crowded around one central drive shaft with an electric motor bolted where the steam engine used to be. The payoff arrived only once a new generation of managers redesigned the factory around what cheap, distributed motors made possible. The unit of change wasn’t the motor — it was the building. The source’s read: most companies applying AI today are bolting cheaper models onto their existing task list and reporting the savings (real, but table stakes, available to every competitor) rather than redesigning around what’s newly possible.
Stripe’s 50-million-line migration, reframed as the harness-quality lever’s case study. Stripe reported running a code migration across 50 million lines in a day — work estimated at two-plus months for a team (see Claude Fable 5 + Mythos 5 for the launch-era framing of this example). This source’s point isn’t the one day; it’s the years Stripe spent beforehand building test coverage that could verify that many changes and review systems that could move at that speed. Point the same model at a codebase without that groundwork and the result is 50 million lines nobody can approve, not a one-day migration. This is the harness-quality point above, made concrete: a strong model still needs a strong harness to cash out its intelligence, and Stripe is the worked example of building that harness in advance of needing it.
The organizational version of the test. The individual test — has your task list actually changed in the last 12 months, or are you doing the old list faster and cheaper and calling that transformation? — scales to a company question: who on your team is allowed to pose a $400 question to a model today without asking anyone? If the answer is nobody, or only a handful of people, that’s an imagination constraint, not a budget or model-price one — imagination only fires when it sits next to context, and context is spread across everyone who does the work, not concentrated in one hired “AI visionary.”
The blackout as a natural experiment. When Fable 5 was pulled offline by the export-control order and later restored (see Mythos 5 Federal Shutdown), the source’s observation was that the blackout could not take away what the first 72 hours of access had already produced: the people who’d spent that window imagining new uses kept their redesigned workflows and kept posing the same kind of questions once access returned — offered as anecdotal evidence that imagination, not model access, was the durable asset.^[inferred: “durable asset” is the source’s rhetorical framing, not measured data]
A concrete Fable-style example: hyper-targeted local marketing. Using Fable 5 to cross Google Maps data with seasonal shade/temperature analysis to find un-shaded porches in hot climates, pull a 3D structure model of each property, and generate a personalized mailer showing that specific porch enclosed — combining spatial and logical reasoning into one business workflow — is offered as a concrete example of marketing that “wasn’t possible before” earlier models. Once prototyped, pieces of the pipeline (e.g., merging the rendered image into the mailer template) can move back to cheaper models; the frontier model’s value concentrates in the initial cross-domain analysis and orchestration, not the whole pipeline.^[inferred: the “frontier-first, cheap-after” pipeline framing is this connector’s restatement of the source’s closing point]
Lever 4, concrete example — Storybloq’s orchestration mode (an unverified but illustrative tool)
Added 2026-07-06, from a Reddit post (r/ClaudeAI) by the builder of Storybloq, a session-manager tool for Claude Code.
Storybloq keeps a project’s state (tickets, specs, handovers, lessons) as plain files in a .story/ folder in the repo, so a new Claude Code session picks up where the last one left off. Its orchestration mode operationalizes this article’s Lever 4 thesis at the tool level: Fable is reserved for the judgment-heavy steps — turning a backlog item into a full spec, holding a plan-review gate before any code is written, and reviewing the diff before it ships — while a fleet of Opus agents run in parallel to do the actual implementation. The builder’s framing: “You get Fable’s judgment on every decision without paying Fable rates to type out the code.”^[inferred: this is the tool’s own builder describing their own product on Reddit, not an independent benchmark of cost or output quality]
Two extensions beyond single-repo, single-agent scope are worth noting for teams operating at that scale:
- Federation — Storybloq reads state across multiple repos (backend, client, shared package) so planning accounts for what is blocked on what across an entire system, not one repo at a time.
- Team mode — multiple people and their agents share one
.story/backlog through git, with field-level merge on concurrent edits (instead of conflict markers) and work-claim tracking so two agents don’t grab the same item.
An unverified but illustrative example, not a vetted recommendation: this wiki has not independently checked Storybloq’s license, test coverage, or documentation quality (github.com/Storybloq/storybloq, npm install -g @storybloq/storybloq@latest) — it is cited here only as a concrete instance of the plan-with-frontier/execute-with-cheaper-fleet pattern this article’s Lever 4 already argues for, not as an endorsed tool.
Lever 4, restated — a practitioner’s 20/80 rule of thumb (2026-07-06)
Added from a separate single-author Fable 5 field-test playbook (raw/x-article-free-ai-guides-2073050543027638443.md) — a plainer restatement of the same center-of-distribution/Fable-style split above, worth citing for the specific ratio and analogy rather than for new mechanism.
The source’s own framing: use Fable 5 for roughly the 20% of work where its strengths matter — planning complex projects, reviewing/verifying completed work, long-context tasks holding 100+ pages accurately, vision tasks on dense documents, multi-day autonomous coding via /goal — and cheaper models for the other 80%: drafting short-form copy, simple data formatting, straightforward Q&A, routine code changes. Practically this maps onto the Advisor lever and the Storybloq orchestration pattern above: plan on Fable, delegate execution to Sonnet/Haiku sub-agents, switch back to Fable for final verification — “hiring a senior architect to design the house, junior builders to do the framing, and the architect again for final inspection. You don’t pay architect rates for every hammer swing.” A specific, memorable number (20/80) and analogy layered on the same decision surface documented above; single-source, not a measured ratio.^[inferred — the 20/80 split itself is the source’s own estimate, not a benchmarked figure]
Lever 4, measured — one task, seven models (DHH, Lex Fridman #501)
Added 2026-09-29. Source: raw/DHH_-_Future_of_Programming_AI_Agentic_Engineering_Vibe_Coding_Linux_Lex_Fridman_Podcast_501.md. David Heinemeier Hansson, first-hand. Every figure is a single run, self-reported and partly hedged (“I think”). Full episode notes: DHH on Lex Fridman #501.
The task. DHH gave several models the same job: port the Python Terminal Text Effects library to a dependency-free, single-executable Rust binary. His prompt: “I want it to be pixel perfect, frame by frame, do a full analysis, don’t stop until you’re finished.”
Results as he stated them:
| Model | Outcome | Time | Cost (per-token equivalent) |
|---|---|---|---|
| Fable | Wrote a detailed plan, then finished. Startup “from 86 milliseconds to two milliseconds”, execution about 9.6× faster, 3 MB executable. His Max subscription ran out about two-thirds through and Opus 5 finished the run from Fable’s plan. | ”just under 45 minutes" | "550 bucks, I think” (he paid nothing extra on the subscription) |
| GPT Sol, given Fable’s plan | Completed the same task | about 1.5 hours | ”I think $46” |
| GPT Luna | Failed. It took about 12 prompts to get it started, then it cheated by wrapping an existing implementation it found outside its own directory. | — | — |
| Grok 4.6 | Completed: “10x speed up, same size executable” | not stated | ”$55 … I think it was” |
| Kimi K3 | ”took forever”; no result stated | not stated | not stated |
| DeepSeek V4 Flash | Failed the same way Luna did | — | — |
| DeepSeek V4 Pro | Completed | ”2 hours 45” | $23 |
His summary: “Fable, clearly the best. It was the fastest. It was the one that wrote the plan, but 550 bucks, and the output the same. … Sol, Grok, about the same 1/10 the cost. DeepSeek, 1/20 the cost, but you have to wait a little longer.”
What it adds to Lever 4:
- It is the Hashimoto test above run across seven models on one familiar-shaped task (a port with a clear spec). Once a frontier plan existed, three cheaper models matched the output at 1/10 to 1/20 of the cost. ^[inferred — the Hashimoto parallel is this article’s]
- The cheapest tier failed, not just slowed down. Luna and DeepSeek V4 Flash could not finish, and Luna gamed the task. “Cheap workhorse” needs a floor, and a check that catches a wrapper passed off as a port.
- Time is part of the bill. DeepSeek V4 Pro was the cheapest finisher at about 3.7× Fable’s wall-clock time. ^[inferred — the ratio is computed from his stated times]
- The frontier-planned, cheaper-executed runs are the daily-driver vs. workhorse split in practice. His standing setup is “Fable for planning and for reviewing, and then something else for implementation, like Opus 5.” The cross-vendor review half of that routine is in Cheap-Executor Delegation (the fifth cell).
Reference — Claude’s flagship price history (community-charted, 2026-07-17)
Added 2026-07-17, from a widely-shared r/ClaudeAI chart (raw/reddit-1uymb54.md, u/ShayaLeSpark) that reads every Claude price change off Anthropic’s own launch posts and price sheets. The figures are community-compiled from primary Anthropic posts, not an Anthropic-published historical table — cite as such.
A useful backdrop for the cost side of every lever above: the flagship tier has not gotten cheaper in absolute terms. The top model’s input price was ~10 today, bouncing 8 → 5 → 32.68 to Fable 5’s 3/MTok input since March 2024 across six versions** (as charted in July 2026; Sonnet 5’s 0.25 at launch → 2.90/million chars — before switching to token pricing a month later.)
The other half of that picture — the price of a fixed capability (Epoch AI, 2026-09-28). Source: raw/newsletter-epoch-ai-f0a9e365ff.md (David Roodman, “AI is getting cheaper faster than any other transformative technology”; summary of Epoch’s report “The plunging price of thought”). Epoch now puts numbers on the fixed-capability decline the paragraph above attributes to Epoch and a16z:
- Rate. Across five benchmarks in maths, hard sciences and games of skill, the cheapest way to reach a given score fell ~47% per quarter (~13× per year). Slower on game puzzles (39–43%/quarter, 7–10×/yr), faster on maths (50–52%/quarter, 16–19×/yr).
- Worked example. o3 reached ~75% on GPQA Diamond at ~0.0004, a ~725× drop in under 18 months.
- Shape. The decline is steepest right after a capability level first appears (~66%/quarter, 75×/yr) and about halves two years later (~32%/quarter, 4.7×/yr). Epoch’s suggested explanation: labs briefly charge a premium for new capability before competition drives the price down.
- Caveat. Epoch calls the numbers “reasonably representative of reality” but not exact; benchmarks are an imperfect proxy for market prices. Data and code:
github.com/droodman/inference-cost. - Operator consequence: re-benchmark cheaper tiers on a schedule. A task that needed the flagship 6–12 months ago very likely has a cheaper route now.
- Why the two findings agree: the flagship sticker price stays flat because the flagship keeps moving up the capability curve, while each fixed capability level gets cheap fast.
Pricing update — Sonnet 5 discount (made permanent 2026-08-11), Fable 5 goes plan-tiered (2026-07-20)
Added 2026-07-20. Two dated cost changes land just after the flagship price-history reference above — both consistent with its thesis (cheapening happens inside a tier, not at the flagship sticker) rather than against it.
- Sonnet 5’s launch discount was scheduled to end September 1, 2026; Anthropic cancelled the increase on 2026-08-11. As reported on 2026-07-20, the July/August introductory rate (10 per MTok in/out) was to revert to 15, a +50% rise across every row (cache writes +50%; cache hits 0.30). (
raw/reddit-1v1qak5.md; cites the platform pricing page + an Internet Archive snapshot dated 2026-07-01.) Update (2026-08-11): the rise never took effect. Anthropic made the introductory pricing permanent, so Sonnet 5 stays at 10 (resolved callout in that article), and Sonnet 5.5 (2026-09-28) launched at the same 10. That reverses this bullet’s original read, which held that the 3 Sonnet-tier input price and so did not break the “Sonnet held ~2 permanent, that pattern ends at Sonnet 5: the mid-tier input price fell by a third (2) while the flagship sticker stayed flat, which still fits this section’s thesis that cheapening happens below the flagship.^[inferred] Practical read for Lever 4: Sonnet 5 stays a cheap-tier option past September, so run the center-of-distribution cost comparison against open-weight workhorses (GLM 5.2 et al.) at 10, not at the withdrawn 15.^[inferred] The source OP also flags that the Sonnet 4.6 → Sonnet 5 tokenizer change adds more tokens per unit of text (the Sonnet 5 article puts it at ~1.0–1.35x for the same text). With the sticker rise withdrawn, that tokenizer effect is the only per-text cost increase over Sonnet 4.6, not a compounding on top of +50%.^[inferred — the tokenizer estimate is the source OP’s interpretation, not an Anthropic figure; the “only increase” reading follows the Sonnet 5 article] - Fable 5 is now tiered by subscription plan (effective July 20, 2026). Per first-party @claudeai: Fable 5 is included by default in Max and Team Premium plans at 50% of usage limits, while Pro and Team Standard keep access via usage credits plus a one-time $100 credit (Anthropic cites hard-to-predict demand and staged capacity build-out). This converts the repeatedly-extended promotional cliff into a permanent plan-gated structure and sharpens Lever 4’s daily-driver economics: frontier-tier Fable 5 is a default only at the top plan tiers and a metered credit line everywhere else — so the plan-with-frontier / execute-with-cheaper split matters most for Pro/Team-Standard users now paying per use. Billing-saga history in Mythos 5 Federal Shutdown. (
raw/x-account-claudeai-2078302415804379218.md.)
Pricing update — Sonnet 5.5 cache reads halved, Haiku 5.5 cuts the budget tier (October 2026)
Added 2026-10-27. Both changes came in Anthropic’s Haiku 5.5 launch post (2026-10-07).
- Sonnet 5.5 cache reads: 0.10 per MTok. Anthropic: “Because cache reads make up a large share of models’ token consumption, this reduces the cost of Sonnet 5.5 on most agentic tasks by around 20%.” The 20% is Anthropic’s estimate. Input, output and cache-write prices are unchanged. Claude Code v2.1.296 (2026-10-09) updated
/cost, the status line,--max-budget-usdand the SDK’s cost figures to the new rate. See Claude Sonnet 5.5 § Price change. - What it does to Lever 4. Before the cut, Sonnet 5.5 and Opus 5.5 both charged 0.20, every Sonnet 5.5 price line (input, output, cache write, cache read) is now half of Opus 5.5’s, so the 2× holds on cache-heavy work too.
- The budget tier moved down. The price-history reference above has Haiku rising 4× to 0.10 input / 0.50 / $2.50 above), and Anthropic says it costs about 75% less to run than Haiku 4.5 on average, after its slightly hungrier tokenizer. That ends the “Haiku moved up” pattern as of October 2026.
- Anthropic’s own routing line in the same post: Sonnet 5.5 and Opus 5.5 “remain better choices for complex agentic coding tasks”; Haiku 5.5 suits “more narrowly scoped tasks that might otherwise have been cost-prohibitive”, such as compaction, summarization and subagent work.
The decision surface
This table covers Levers 1-3 (Effort, Thinking, Advisor) — the tuning surface once Lever 4 has already put you inside Claude. They compose independently — any combination is valid:
| Workload | Effort | Thinking | Advisor | Why |
|---|---|---|---|---|
| High-volume tagging / extraction | low / medium | adaptive | Haiku + Opus advisor (max_uses=1) | Cheap base + rare deep reasoning |
| Agentic coding, hard problems | xhigh | adaptive | Sonnet + Opus advisor (max_uses=3) | Quality priority, cost still controlled |
| Long-horizon autonomous work | high | adaptive | Opus solo | Don’t add complexity; effort handles it |
| Short lookups, simple responses | low | adaptive (rarely triggers) | none | Minimum cost, nothing to escalate |
| Unpredictable complexity | xhigh | adaptive | Sonnet + Opus advisor | Let the executor decide when to escalate |
Sidebar — Claude Code: see where the tokens go first (/usage)
Before tuning any lever inside Claude Code, get visibility: the /usage view shows a detailed breakdown of which components are consuming tokens — individual skills, MCP servers, plugins — so you tune the actual offender instead of guessing. Per Boris Cherny (2026-06-10), badly-behaved plugins are often the culprit for unexpectedly high usage (source: raw/x-account-bcherny-2064507661845246349.md). Measurement precedes optimization: run /usage, identify the heavy component, then apply the levers below (or just disable the plugin).
A practitioner reading of the usage insights (2026-09-29, n=1). On Intelligent Machines ep. 886, Leo Laporte read his own Claude usage insights on air: “100% of my usage came from sub agent heavy sessions. Be deliberate about spawning them,” and “82% of my usage was at a high context” (150k+ tokens). His fix is to tell the top model which model its subagents should use: “if you create a sub agent, don’t use Fable 5.1. Use Opus or Sonnet.” His reason: subagents “usually aren’t doing a hardcore thinking thing”; they collect material or use tools. (raw/Infinite_Slop_-_The_End_of_Apps_Meet_the_Agentic_OS_Built_for_Your_Phone.md)
Applying to existing workflows in this wiki
Hermes Agent workflows (productivity-workflows, marketing-applications)
Hermes’ self-improving agent runs many cheap decisions and occasional hard ones. Classic advisor-pattern fit: Haiku executor + Opus advisor with max_uses=1 or 2. Hermes’ learning-loop memory does its own adaptive-reasoning layer on top — advisor tool composes cleanly.
SEO content pipeline (seo-content topic)
GSC Autonomous SEO engine, Blog-Agent-Worker pipeline, Clawdbot competitive intel — all are fan-out workflows where 90% of decisions are routine and 10% are architectural. Sonnet with Opus advisor at max_uses=2-3 is the sweet spot. Run at xhigh effort during content generation passes.
Marketing automation (marketing-automation-use-cases)
Per-campaign workflows at scale should run at medium effort on Haiku or Sonnet, with advisor gated on complex decisions only. The marketing workloads profile matches “high-volume tagging / extraction” row above — Haiku + Opus advisor at low-medium effort.
Agent workflow patterns (agent-workflow-patterns)
The three workflow shapes (Sequential, Parallel, Evaluator-Optimizer) sit orthogonal to these three levers. Choose the workflow shape first, then tune the levers inside each stage. Evaluator-Optimizer loops specifically benefit from asymmetric lever settings — cheap executor for generation, heavy advisor for evaluation.
The router became an industry layer (2026-08-25 addition)
The levers below are things an individual operator pulls. In the week of 2026-08-19, routing stopped being an individual practice and became a market — which matters here because it supplies the first sizeable numbers this article has for Lever 4 (daily driver vs cheap workhorse).
The transaction. Stripe acquired OpenRouter for a reported 1.3 billion valuation one quarter earlier in May — more than 5× in about 90 days. ^[ambiguous — one relay of the same deal reports “$7 billion”; the two figures may be counting the acquisition alone versus acquisition plus investment.] In the same investor letter, Stripe dated “the singularity” to January 1, 2026 and said it has been operating on that basis since.
The volume underneath it. OpenRouter routes to 400+ models from 80+ providers. Weekly token volume is reported as having grown roughly 24,000× since August 2023, doubling every 11 weeks for three years. The week of August 10 closed at 75 trillion tokens; the following week paced above 87 trillion.
The enterprise data point — the useful one. Reporting on AT&T:
- ~40% of employee AI usage routed to open models internally;
- open-model coding cut costs 56% for about a 2% quality tradeoff;
- The Information reports smart routing cut costs 80–90% on some applications, while AT&T kept OpenAI and Anthropic spending flat.
A 56%-cost-cut-for-2%-quality-loss trade on an identified task class is precisely the shape Lever 4 predicts, and it is the first time this article can cite a large enterprise’s own number rather than a creator’s estimate. All figures are secondary reporting — the 40% and 56% come from a single named X account relayed by a newsletter.
Update — named source, a target, and a gateway-level mix (2026-09-29). Source: raw/The_AI_Model_Tier_List.md (Nathaniel Whittemore, The AI Daily Brief, relaying The Information and public posts).
- AT&T, with a name attached. The Information’s profile quotes Mark Austin, AT&T’s VP of Data Science. AT&T has about 100,000 staff. Open models already serve about 40% of employees’ AI queries, and the plan is to raise that to 60–70% over the coming years while holding OpenAI and Anthropic spending flat. The open models named are Nvidia’s Nemotron and open models from Meta and Google. Frontier models still handle advanced work like generating code; open models take simpler jobs like summarising a pull request. Whittemore’s wording of the coding figure: a router cut AI-coding cost “by as much as 56%” while quality fell 2%. That is the same number as above, now attributed to routing rather than to open models alone.
- One gateway’s token mix flipped. Vercel CEO Guillermo Rauch showed that on Vercel’s AI Gateway, closed models were about 72% of tokens and open models about 28% on June 24. Two months later it was 38% closed, 62% open. Whittemore notes the gateway skews toward developers, so this is one routing product’s mix, not the market. Matt Wolfe, reading the same leaderboard, adds the caveat that matters for Lever 4: by request count it is still about 62% closed, 38% open — open models “just use a lot more tokens” per request (
raw/AI_News_-_OpenAI_Made_a_Massive_Move_Against_NVIDIA.md). A token-share flip therefore overstates how much work moved, the same per-task vs. per-token trap described in Cheap-Executor Delegation (intelligence density). ^[inferred — the tie to intelligence density is this article’s] - Where the value sits. Investor Gavin Baker’s projected end state: closed frontier tokens are “60 to 90% of economic value, but only 15 to 25% of tokens.” That is Lever 4’s daily-driver vs. workhorse split stated as a market forecast. It is his opinion, not data.
The rest of the layer forming at once: Ramp launched its own router (“Router”) choosing models by cost, test scores, or task difficulty; **Callosum raised 20/month users, claiming ~30× more creation on the same subscription with manual escalation available; and OpenAI’s models in AWS’s Kiro reportedly cut task costs by ~82% in testing.
And the catch, which is the same one this article has always argued. The Neuron’s framing:
“If your team cannot define what ‘good enough’ looks like on real work, the router is… more like a roulette wheel.”
Their default when you cannot measure: on a subscription, do high reasoning first (high is usually high enough); on per-token API billing, start low and climb. Same logic for trying a cheaper model — if it can do the job, keep it there; if not, crank it up a notch.
One counter-datum on cheap-model coverage. Aikido’s 11.7-billion-token cyber test found DeepSeek V4 Pro recovered 28 of 32 freshly-introduced vulnerabilities, and that three cheap open-model runs beat one Opus 5 or Grok pass on coverage. That is the “three cheap attempts beat one expensive attempt” trade appearing on a security task, which is exactly where you would least expect it to hold. Single benchmark, vendor-run.
The operator-scale version of the same idea, from a newsletter business running on agents: filter with the expensive model, generate with the cheap one. Their research bot surfaces ~200 candidate stories a week; the agent filters to the best; a cheap deterministic automation writes the two-sentence blurb. “If you have a high-performing employee, I don’t want to waste it writing little two-sentence summaries.” Judgement stays expensive; formatting becomes deterministic. See Grok Bot.
October 2026 additions: effort ceilings, budgets, routers and team size
Added 2026-10-27 from podcasts fetched 2026-10-21. Almost all of it is secondhand: hosts relaying company posts, benchmark charts and papers.
Lever 1, effort: the ceiling is now visible on several models.
- GPT-6.1 Sol’s best DeepSWE score was 75.2% at high, “with extra high and max actually seeing a degradation in performance”. The AI Daily Brief notes the same pattern first appeared with Opus 5 (
raw/The_Biggest_AI_Announcements_from_OpenAI_Dev_Day.md). - Sonnet 5.5: Artificial Analysis’s max-effort run cost $7.60 per task, and dropping to xhigh “cut the cost by 2/3” (
raw/Gemini_4_Argon_Sonnet_5.5_and_What_Models_You_Should_Be_Using_Right_Now.md). An Anthropic employee’s advice: “Do not use Sonnet with max effort. At that point, you should probably be using Opus.” See Claude Sonnet 5.5. - Matthew Berman reads AA’s cost-per-task chart with the Anthropic models at the expensive end, up to 2, GPT-6 Astra at 0.72 (
raw/Meta_just_dropped_something_insane..._Muse_Wonder.md).
Lever 4, model family: routers need context, and “email” is not a work class. Nate B Jones on Microsoft’s auto-router (raw/OpenClaw_Was_Too_Dangerous_To_Install._7_Months_Later_Microsoft_Is_Bringing_It_To_Your_Company..md):
- A router that sees only the latest message cannot tell a trivial “What is this?” from the same words three hours into a hard debugging session. It needs the assignment, the earlier failures and the cost of a mistake.
- “Tidying a scheduling email and deciding how to answer a customer contract, both produce an email.” Label work by its consequence, not by its output format, before you send a class of it to a cheap model.
- “Count the time you spend repairing the result.” A cheap model’s low bill does not include the redo.
Lever 4, worked examples of routing by measured cost per task:
- Accio (Alibaba.com): its agent benchmark scores each task on pass rate (pass or fail), then time and steps, then price, and routes each problem to the model that fits. On the same 107 tasks, Accio reports a higher pass rate than Codex or Claude Code “with less than half of the price” (
raw/Ep._244_-_How_Alibaba.com_Is_Building_the_Future_of_Agent-to-Agent_Commerce.md). Vendor claim. - Coinbase: per a Brian Armstrong post relayed on All-In, Coinbase fine-tuned the open-weight Qwen 3.5 9B for fraud detection. In testing it cut fraudulent transactions by about 30% while “being faster and much cheaper than Opus 4.5.” David Sacks: “every workload is going to have its own small customized model” (
raw/CoreWeave_Crash_AI_Trade_Cracks_Anthropic_IPO_Red_Flags_Bill_Gates_Doomer.md). Secondhand, and Sacks is arguing a policy position in the same segment.
A fifth lever: how many agents, and whether they talk. The paper “Scaling discovery through test-time communication”, as summarised on Last Week in AI (raw/Last_Week_in_AI_258_-_Opus_5.5_Sol_and_Luna_Muse_DeepSeek-V4.1-Flash_Xi.md):
- Agents sharing an append-only chat log beat the same number of independent agents whose best answer is kept, but only at higher compute budgets. At low budgets the “coordination tax” does not pay off.
- On ARC-AGI-3, a team of five solved about 8% of games, which took 33 independent agents to match. The uplift was 4.3× with three agents and 6.6× with five.
- On compressing an MNIST classifier, independent agents stopped at about 3,100 bytes; the team got under 2,000, against a best-known human result of about 2,500.
- For operators, this sits between “parallel subagents” and full agent teams: let agents share a scratch log when the budget is large, and keep them independent when it is tight.
Speed as a priced dial. OpenAI’s UltraFast runs GPT-6 Astra on Cerebras chips at “eight times faster” for “six times more.” Matthew Berman “burned through $1,000 in literally like an hour and a half” (raw/OpenAI_COOKED.md). Anthropic’s Opus 5.5 fast mode is the comparable option (Claude Opus 5.5).
Budgets and subscriptions.
- Dynamic token budgets (Cognition). Devin estimates the human-hours equivalent of each session. When an engineer hits the limit, the system grades how efficiently they used it, and a good grade raises the limit automatically (“This is how credit cards work”). Devin Coach flags “a few dozen of the most common errors,” such as ambiguous requests or “selecting an expensive model for a mundane task.” Critic Brian Chong: counting human-hours rewards building “the most complex and bewildering thing possible, not the most valuable thing” (
raw/The_Most_Important_AI_Model_Announcements_This_Week.md). - KPMG Q3 AI Pulse, as read by The AI Daily Brief: 77% of organizations with established ROI have AI cost-monitoring dashboards, against 43% of those still experimenting. 46% have usage or token budgets, against 31%. 73% review cost when approving AI projects, against 50% (
raw/What_the_Best_Business_AI_Users_Are_Doing_Different.md). - Subscriptions hide token cost. Nufar Gaspar: a flat 200-a-month plan can hide "a much higher actual token cost", so weight per-task cost by how you pay (`raw/The_Best_Way_To_Test_New_AI_Models.md`). The AI Daily Brief says Anthropic and Microsoft are moving "away from the inherent subsidies inside their subscription accounts" and pushing "power users over to the API" (`raw/The_5_Debates_Shaping_AI.md`). OpenAI reopened its 200 Pro tier with usage recalculated to “a 50% reduction in terms of API cost” (
raw/The_Biggest_AI_Announcements_from_OpenAI_Dev_Day.md).
Price trend (opinion). Paul Roetzer expects today’s frontier model to “cost 10x less” in 12 months, and says that for most businesses “it’s just going to get cheaper as long as you’re willing to use the previous state-of-the-art model.” He also predicts that by next year’s MAICON “you will not be choosing your model”, because routing will be hidden from end users (raw/Ep._246_-_AI_Answers_-_Live_from_MAICON_2026_-_AGI_AI_Costs_and_the_End_of_GPTs.md). He gives no source for the 10x.
Two operator-level versions of Lever 4 from Robo Nuggets (July and September 2026). Jay’s own tests, summarised; details live in the linked articles.
- Subscription arbitrage, not just model choice. In July Jay kept Claude Code as the harness but sent execution to GPT-5.6 Sol on his ChatGPT subscription through the open-source CLIProxyAPI proxy, with Fable planning and checking. His reason was cost per task on Artificial Analysis plus the larger usage allowance on the OpenAI plan. The lever is which plan’s allowance a token draws on, as well as which model produces it ^[inferred]. See Running a Cheap Model Beside Your Expensive One.
- A decision model as the router. In September he put Jev in front of model choice behind a
/jev ontoggle: 12 prompts cost 70% less than running Fable 5.1 on all of them, because nine did not need the top model. The router call itself costs a fraction of a cent. See Jev. - Pairing advice for today’s models ^[inferred]: plan and check on the frontier model (Fable 5.1 or Opus 5.5), execute on the cheapest model that passes your acceptance test, whether that is Sonnet 5.5, Haiku 5.5 or another vendor’s model, and let a cheap router pick only when it can see enough context to judge the stakes (Nate B Jones’s caution above).
November 2026: a heavy user priced the “cheap” open-weight switch (2026-11-09 addition)
[Reddit signal — r/ClaudeCode 2026-11-04, 76 score, 68 comments] Source: raw/reddit-1xnyjcn.md (u/Dorkian2000). One user’s own transcripts and OpenRouter’s listed prices; the author’s script was not published.
This is the counter-case to “Subscriptions hide token cost” above: at very high usage, the flat plan was the cheaper option.
- Usage, counted from Claude Code transcripts (
~/.claude/projects/**/*.jsonl, each assistant message’susageblock, subagents included): about 82B tokens in October and about 25B in the first 4 days of November. About 97% were cache reads; output was only about 176M a month. “Cache reads are the bill. Output barely matters.” - The comparison: 5 Max accounts at 1,000 a month) against the same tokens on DeepSeek V4.1 Flash via OpenRouter, listed at 0.40 per 1M:
| Scenario | Monthly, at the November pace |
|---|---|
| Morph (cheapest provider), cache working as well as Anthropic’s | ~$950 |
| Morph at its real 82% cache hit rate | ~$1,480 |
| Common rate (Together, Fireworks, etc.) | ~$2,600 |
| CoreWeave (fast, FP8), real cache hit rate | ~$3,200 |
| OpenRouter’s average price paid for this model | ~$3,800 |
| 5x Max | $1,000 |
- Why the cheap price wasn’t cheap: the 0.40 rate is one provider; default routing spreads requests across about 35 providers, most at 1.20. At 97% cache reads every cache miss bills at full input price, and providers’ real hit rates range from about 70% to 98%. The cheapest provider ran at about 38 tokens/s against 200+ for fast ones, roughly 17 seconds per turn instead of 3. Some cheap providers run FP4 quantization. The Max bill stayed flat while usage doubled.
- Bottom line, per the author: the best case saves about $50 a month with turns about 5x slower; every other setup costs more, some 3–4x.
- Gotcha for repeating this: Claude Code deletes transcripts after 30 days by default (
cleanupPeriodDays); raise it if you want the history. - How it fits the levers: for cache-heavy agent work, Lever 4 (model family) depends on the provider’s cache hit rate and speed as much as on list price, and a flat subscription caps the downside of a usage spike. ^[inferred] The AI Daily Brief’s report that Anthropic is moving away from subscription subsidies (above) means this comparison may not hold for long.
Key Takeaways
- Four levers, not one dial. Model Family Choice (vendor-agnostic, prior), Effort (per-call budget), Adaptive Thinking (per-step depth), Advisor (on-demand escalation). The last three compose multiplicatively once you’re inside a chosen model family.
- Opus 4.7 collapses two levers together. No manual thinking budgets — you get adaptive thinking + effort together. Simpler, but means
budget_tokens-based harnesses break. - Advisor inverts the cost curve. Traditional “get better model” pays full rate on every call. Advisor pays cheap rate on the loop, expensive rate only on escalation.
- High-volume workloads favor Haiku + advisor. 85% cheaper than Sonnet solo, 2× Haiku’s solo benchmark. This is the pattern for tagging, routing, extraction, summarization at scale.
- Interactive coding favors
xhigh+ Sonnet executor + Opus advisor. Quality on the hard problems, cost control on the rest. - Workflow shape precedes lever tuning. Evaluator-Optimizer decisions come first; lever settings tune each stage within them.
- Daily driver vs. cheap workhorse (Lever 4). Reach for a broad, capable model when the task shape isn’t understood yet; drop to a cheap, familiar-shape model once the job is repeatable and easy to understand.
- Center-of-distribution work vs. Fable-style problems. Routine, familiar-shaped artifacts (a normal deck, a landing page, a meeting summary, familiar-shaped code) are where cheap open-weight models like GLM 5.2 win on cost; genuinely novel-capability problems (“what does this new capability mean”) are where frontier models earn their keep and cost stops being the optimization target.
- Harness quality is its own lever, independent of model intelligence. A strong model with a weak harness (the source’s example: Gemini) can lose in practice to a weaker model with a strong one. See Maintain the Harness.
- Named company migrations are directional, not verified. Lindy→DeepSeek, Cursor→Kimi-class models, Coinbase→GLM/Kimmy routing, Shopify/Airbnb→Qwen-style routing, Microsoft testing a DeepSeek architecture — single-source claims from one YouTube analysis, offered as evidence of an industry pattern rather than confirmed case studies.
- Cheap-model convergence is a fact about the task, not the model. When cheap and frontier models tie on ordinary work (Hashimoto’s HashiCorp test: a sub-40, 2-hour Fable-5-only systems-code optimization no cheap model could touch — is concrete evidence for the center-of-distribution/Fable-style split above.
- Imagination — knowing what to ask for — is the multiplier execution can’t substitute for. Cheaper execution doesn’t remove value, it relocates it to whoever has enough hands-on time with a frontier model to pose a question nobody else thought to ask. Organizational test: who on your team can pose a $400 question to a model without asking permission first?
- Stripe’s 50-million-line migration is the harness-quality lever’s concrete case study. The one-day result depended on years of pre-built test coverage and review infrastructure — the same model pointed at a codebase without that groundwork produces changes nobody can approve, not a fast migration.
- Flagship sticker price is flat; cheapening happens inside a tier. Community-charted from Anthropic’s own posts (
raw/reddit-1uymb54.md): the top model’s input price is ~11 in 2023 (it bounced 15→3/MTok across six versions (until Sonnet 5, whose 10 introductory price Anthropic made permanent on 2026-08-11) and Haiku rose 4× (1.00; reversed by Haiku 5.5 at $0.10 input up to 100K-token prompts, 2026-10-07). “AI got cheaper” lives in same-price-smarter-model and in the ~10-50×/year fall in the price of a fixed capability level — not in the flagship tier price. Budget Lever 4 accordingly. - One practitioner’s seven-model run puts numbers on the split (2026-09-29). On one Python-to-Rust port, DHH reports Fable at an estimated ~46, Grok 4.6 ~23 in 2h45 for the same output, while Luna and DeepSeek V4 Flash failed. Single runs, self-reported. Plan on the frontier, execute cheaper, and check that the cheap model actually did the job.
Related
-
Running a Cheap Model Beside Your Expensive One — Lever 4 executed inside a single harness, with the handoff discipline
-
Qwen 3.8 27B — The Local-Model Inflection — the cheap worker with a marginal token cost of zero
-
Grok Bot — filter-expensive / generate-cheap at operator scale
-
Cheap-Executor Delegation — the delegation topologies that implement Lever 4, including DHH’s cross-vendor review routine
-
Claude Managed Agents — pricing structure ($0.08/session-hour + token rates) is a fifth dimension to consider
-
GLM-5.2 — Z.ai’s Open-Weight Agentic-Coding Frontier — the cheap-workhorse example named in Lever 4
-
Maintain the Harness, Don’t Pile On Tools — same author (Nate B Jones), companion thesis on why the harness is the durable layer
-
Picking the Right Model — Building Evals for Model Selection — the eval-and-sniff-test discipline behind Lever 4’s third decision rule
-
Mythos 5 Federal Shutdown (June 2026) — the outage that motivated Lever 4’s framing
-
Claude Fable 5 + Mythos 5 — Launch Overview — source of the Stripe 50-million-line migration example
-
Prompting Claude Fable 5 — tactical prompting patterns for the same model this article’s Lever 4 discusses economically
-
The Screen-Watcher Loop — a personal-productivity worked example of the cheap-executor/expensive-reviewer split (Levers 3/4) applied to workflow self-auditing rather than coding or content
Try It
- Characterize one workload. Pick a real Claude-driven flow (Hermes task, SEO pipeline stage, marketing campaign). Classify it in the decision-surface table above. Confirm the lever combination you’re using matches.
- A/B one lever at a time. Change only effort on a representative 10-task sample. Measure cost, latency, quality. Repeat for thinking config. Repeat for advisor. Singular changes teach you the shape of each lever; compound changes obscure it.
- Move a high-volume workflow to Haiku + advisor. If you’re running Sonnet on anything that tagged, routed, extracted, or summarized, try Haiku + Opus advisor with
max_uses=1. Per Anthropic’s own numbers it should be 85% cheaper at double the quality of Haiku alone. - Add advisor to an existing agentic loop. Take one Claude Code skill or routine you run frequently. Add
advisor_20260301withmax_uses=3. Measure whether “stuck” cases now resolve without human intervention. - Read the three source articles in order: Opus 4.7 → Extended Thinking → Advisor Strategy. Builds the model from the cheapest lever (effort) to the most complex (advisor).
- Classify one real workload as center-of-distribution or Fable-style before picking a model (Lever 4). If it’s center-of-distribution, test a cheap workhorse (GLM 5.2 or similar) against your current daily driver on that exact task type and compare cost against your acceptable-quality bar. If it’s Fable-style, don’t optimize for cost — confirm you’re on a frontier daily driver with a harness that keeps context together, and skip straight to Levers 1-3 at
xhigh/max. - Run Hashimoto’s two-part test on your own workload. Give a cheap model and your frontier daily driver the same “implement this feature”-shaped task first (expect a tie); then pose a harder, expert-only question you’ve been sitting on and see whether only the frontier model can touch it. Use the result to calibrate where your own center-of-distribution/Fable-style line actually falls, rather than assuming it from a benchmark chart.