Cost & Intelligence Levers for Agent Workflows

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 $11permilliontokensin2023.Todayi{t}^{\prime }s$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)

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”):

1. 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.
2. Ask how hard the work actually is, not how much of it there is. Volume doesn’t imply difficulty.
3. 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.
4. 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.
5. 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-$1open-weightmodelandGPT-5.5)onordinary"implementthisfeature"work:allthreetiedonoutputquality—thecheapmodelfinishedinminutesforunderadollar,GPT-5.5costabout$1.50, Fable 5 cost $9andtook40minutes,a9xpricegapforequivalentoutput.Takenalone,tha{t}^{\prime }sthe"routeeverythingtocheapmodels"hottaketheresultlaunched{.}^{[}inferred:"hottaketheresultlaunched"paraphrasesthesourc{e}^{\prime }sdescriptionofthereaction,notacitedsurvey]ButHashimotoranasecondtest:hehandedFable5aproblemthecheapmodels"could{n}^{\prime }ttouchatall"—optimizingagnarlypieceofsystemscodeh{e}^{\prime }dwrittenhimself.Ittook2hours,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 $40question,bycontrast,wasneveronabacklogorsprint—noprocessgeneratesatasklikethat;heposeditbecausedeephands-ontimewiththemodellethimsenseanewcapabilityhadbecomepossible.ThisreframestheceilingonwhatAIisworthtoapersonorcompany:notthemodel,theprice,orthepromptpack,butthesizeofyourlistofthingsyouknowhowtoaskfor.Executionstillmattersenormously(the$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]

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 ~$11.02/MTokin2023and$10 today, bouncing $11\to$8 → $15\to$5 → $10inbetweenratherthanfalling—andonoutputitmovedtheotherway,fromClaude{1}^{\prime }s$32.68 to Fable 5’s $50(50$3/MTok input since March 2024 across six versions** — same price, stronger model each release — which the poster argues is where “AI got cheaper” really lives. The budget tier moved up (Haiku $0.25atlaunch\to$1.00 today, 4×). The reconciling distinction, and the one that matters for Lever 4: this chart tracks named-tier sticker prices, a different quantity from the ~10-50×/year fall in the price of a fixed capability level (the post attributes this to Epoch and a16z) — capability-per-dollar improves fast even while the flagship sticker price stays flat.^[inferred: the tie-back to Lever 4’s daily-driver-vs-cheap-workhorse split is this connector’s framing] Practical read: budgeting a workflow on “the flagship will get cheaper” is unsupported by the tier history; budgeting on “this year’s mid-tier does what last year’s flagship did, at the mid-tier price” is exactly the center-of-distribution migration Lever 4 already argues for. (Aside from the same post: in March 2023 Claude briefly billed per character — $2.90/million chars — before switching to token pricing a month later.)

Pricing update — Sonnet 5 discount expires, 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 ends September 1, 2026. The July/August introductory rate ($2/$10 per MTok in/out) reverts to the standard $3/$15 — a +50% rise across every row (cache writes +50%; cache hits $0.20\to$0.30). This does not break the “Sonnet held ~$3/MTokinputacrosssixversions"patternchartedabove:the$2 was a temporary launch discount below the durable $3Sonnet-tierinputprice,andSept1simplyrestoresit.PracticalreadforLever4:throughJuly/August[[claude-ai/claude-sonnet-5|Sonnet5]]wasagenuinecheap-tierbargain,butfromSeptemberitpricesatthestandardmid-tier—sore-runthecenter-of-distributioncostcomparisonagainstopen-weightworkhorses([[claude-ai/glm-5-series-zai|GLM5.2]]etal.)atthe$3/$15 rate, not the intro rate. The source OP also flags that the Sonnet 4.6 → Sonnet 5 tokenizer change adds more tokens per unit of text, compounding to a larger effective increase than the +50% sticker.^[inferred — the tokenizer-compounding estimate is the source OP’s interpretation, not an Anthropic figure] (raw/reddit-1v1qak5.md; cites the platform pricing page + an Internet Archive snapshot dated 2026-07-01.)
• 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.)

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).

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.

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-$1model,GPT-5.5,andFable5allproducedequallyacceptableoutputon"implementthisfeature"),i{t}^{\prime }sbecausethattaskisalreadywell-understoodandwidelyprompted.Thesametes{t}^{\prime }ssecondhalf—a$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 ~$10/MToktodayvs$11 in 2023 (it bounced $8\to$15→$5,neverfell),whileSonnetheld$3/MTok across six versions and Haiku rose 4× ($0.25\to$1.00). “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.

Related

• The Advisor Strategy (advisor_20260301)
• Extended Thinking (API Reference)
• Opus 4.7 Best Practices for Claude Code
• Claude Prompting Best Practices
• Agent Workflow Patterns
• Claude Managed Agents — pricing structure ($0.08/session-hour + token rates) is a fifth dimension to consider
• Hermes Productivity Workflows
• SEO Content topic index
• Marketing Automation Use Cases
• 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
• All connection articles

Try It

1. 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.
2. 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.
3. 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.
4. Add advisor to an existing agentic loop. Take one Claude Code skill or routine you run frequently. Add advisor_20260301 with max_uses=3. Measure whether “stuck” cases now resolve without human intervention.
5. 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).
6. 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.
7. 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.