Cost Series — The Bill

Working notes. These are the planning pages for a video series — posted ahead of production, outline-first, and they'll shift as episodes get scripted. They read like notes because they are notes.

A series about the economics of running LLMs: what you actually pay, how to measure it, and how to drive it down without wrecking quality. Sibling track to the Fleet Series — that one is about building the fleet; this is about what it costs to run.

"The Bill" is the working title (on-thesis: the bill is not the token count).

The series thesis

One sentence: stop counting tokens; price the work. Caching and model tiering broke the old token↔cost equivalence, so minimizing tokens now optimizes the cheapest axis while ignoring the expensive ones (output and model choice). The real objective is cost per unit of useful work — and the levers are routing, cache hit rate, and output discipline.

The cost model (the durable structure — confirm live pricing at script time)

Cost is not flat per token:

• Cached input read ≈ 0.1× base input (a ~90% discount) — the cheapest token there is.
• Cache write ≈ 1.25× (5-min TTL) or ≈ 2× (1-hr TTL) — an investment that pays back after ~2 reads.
• Output ≈ 5× input, and uncacheable — the expensive axis nobody counts.
• Model tier ≈ 15–20× between a small model and a frontier one — the single biggest lever.

So, roughly: cost ≈ Σ(fresh×1 + cache_write×1.25 + cache_read×0.1 + output×5) × model_price. Two systems with identical token counts can differ 10×+ in cost. (Multipliers are directional and provider-specific; pull exact current numbers when scripting.)

Episodes

• 01 — The Bill Is Not the Token Count — the equivalence that broke (the thesis / hook)
• 02 — Measure the Right Thing — cost per task, broken down by axis and by model
• 03 — Caching as Architecture — stable-prefix design, TTL, the write break-even
• 04 — Classifiers & Routing — the 15–20× lever; cheap-first-then-escalate
• 05 — Output Discipline — the expensive, uncacheable axis
• 06 — Cost per Success — the evaluator ties cost to quality (bridge back to the Fleet Series)

Suggested watch order is numeric; every episode opens with a 20-second "why tokens ≠ cost" recap so it stands alone.

Relationship to the Fleet Series

• Shares the "what are you optimizing?" theme with Fleet Series 11 — The Two Loops You Still Drive.
• Expands the small "cost acceleration" seed already noted in Fleet Series 09 — The LLM Router.
• Episode 06 (cost per success) is the billing-lens view of Fleet Series 05 — Gates: the Evaluator Is the Product — you can't optimize cost-per-success without an evaluator to define success.

Source material / demos (this is grounded in real work, not theory)

• The ongoing token-usage / cached-read analysis — the raw material and the on-camera charts.
• The A/B baton: resume the same session state under model/config A vs B and compare token, cache, and output cost — the measurement rig for episodes 02–04.
• The usage ledger — per-run/per-epic token + spend accounting from the fleet's loop hardening.
• The local LLM router and the classifiers in front of it — live examples of routing/classification as cost control (episode 04).

Format notes

• Each episode: YouTube video + companion blog post from the same outline.
• Every demo will be real — actual usage data and bills, not invented numbers.
• A resources page (provider pricing/caching docs) will follow, mirroring the Fleet Series one.