Token Economics

The Bill Nobody Saw Coming

A $200/mo plan ≈ $14,000/mo of real compute — a ~70× subsidy someone is paying.

Community estimates put a heavily-used $200/mo plan at $14,000–35,000/mo of real compute — estimates disagree 2×, but the shape holds: sticker and consumption aren't in the same order of magnitude. Someone is paying the difference.

Forbes · Jul 2026

"AI Costs More Than The People It Replaced."

Uber reportedly burned its whole 2026 AI coding budget in 4 months.

Github Copilot, Reddit

One developer who went from ~$39 subscription to pay-as-you-go got bill of ~$47,000.

Every AI Session Has a Meter Running

• We watch output quality. We ignore the token counter.
• Then the monthly bill — or "context limit reached" — shows up.
• Token discipline isn't a personal habit — it's a team cost lever.

Cost ≠ Price Per Token

Explore → Plan → Execute → Verify

• Explore — scope it yourself. Never "fix the payment bug"; point it at the component and store. Your codebase knowledge is free; the agent's exploration is not.
• Plan — in read-only mode. Plan Mode blocks write tools at the permission level. Reading a plan takes 2 minutes; reading a wrong 300-line diff takes 20.
• Execute — only after you approve the approach. A plan costs hundreds of tokens; a wrong implementation costs thousands — twice-reviewed.
• Verify — the loop exits on green, not on confidence. The judge is the test runner's output, never the model's opinion of itself.

Boris Cherny — the creator of Claude Code — starts most of his own sessions in Plan Mode. The people who built the tool don't trust it unplanned.

Grill: The Agent That Attacks Your Plan

• A skill whose entire job is to be hostile to the work before it — a skeptical staff-engineer review.
• Severity ladder: blocker · critical · major · minor. Verdicts: pass · pass with conditions · needs rework · reject — and reject fires.
• Non-optional: spec and plan invoke it automatically. A critic you can skip is a critic you skip on the day you needed it.

The cheapest attempt-killer we've built: a rejected plan costs 5 minutes; a rejected implementation costs an afternoon and two reviews.

The Cheapest Reviewer Is Your Own Diff

Feature works? Don't raise the PR yet — run the agent over your own diff first.

• Private — the embarrassing stuff gets caught before a colleague ever sees it.
• Cheap — input is a few thousand tokens of diff; and it kills most of the review-bounce cycle (attempts, at PR granularity) before it starts.
• Consistent — the checklist is a skill (pre-review) backed by an 800-line coding-standards doc the agent must read: versioned, PR-reviewed, executed identically by junior and senior. Review culture, under version control.

Tests: The Honesty Rules

Bonus for every 15-year-old codebase: characterization tests on legacy code — pin down current behavior before touching it. Used to be a week nobody would approve; now it's an afternoon.

Cheaper Per Token ≠ Cheaper Per Task

And it's the whole field, not one vendor: $2.73 per task at the top (Claude Fable 5) down to cents for open-weight models — a spread of roughly two orders of magnitude, same benchmark, same month.

Artificial Analysis, cost-per-task, Jul 3 2026.

The unit that matters is the completed task — in either direction: don't buy a Ferrari for the grocery run, don't buy per-token "savings" that triple the attempts.

Pay for Reasoning Only When Needed — Every Vendor Has a Ladder

Same Arithmetic, Different Tools

Pick the tool for the constraint that binds: data residency → local · flexibility → OpenRouter/OpenCode · out-of-the-box quality → Claude Code/Codex.

The Bill Isn't Only Tokens

• Every parallel agent session is a concurrent process on the same CPU, RAM, and battery — a throttled laptop produces worse agent output long before the API bill is the bottleneck. Our fix: a guard that skips heavy hooks when load > 50% of cores or free memory < 2GB.
• Local models shift the cost, not remove it: $0/token trades for GPU/RAM hardware, electricity, and slower throughput — real money, just billed differently.

Bigger Window ≠ Better Recall

Accuracy drops as token count climbs — even well inside the limit. Context rot is real; the fix is a smaller haystack, not a bigger window.

• On-demand retrieval: our knowledge graph (graphify + code-review-graph) indexes 1,000+ files for 0 LLM tokens (Tree-sitter → SQLite); skipping it burns ~20,000 tokens re-orienting every session.
• Enforced, not requested: a hook intercepts every grep the agent tries — if the graph can answer, the grep is blocked, and the refusal message prices it: graph ≈ 100 tokens vs. ≈ 1,500 for the search sweep — a rule in a hook is a constraint, not a request.
• Subagents with clean, disposable context — the transcript gets thrown away, only the conclusion survives.
• Compact deliberately: long session? Summarize and start fresh instead of replaying the whole transcript — same discount as caching, applied to session length.
• Prompt caching — big enough to get its own slide →

The Single Biggest Zero-Quality-Loss Lever

The provider already computed your static prefix last call. Keep it warm → reuse it at a fraction. Output is byte-identical; only the bill and latency change. ~90% off the cached input is the number all three majors converge on.

Reuse Beats Re-Derivation

One real session — this repo's own memory index.

Capture once. Read forever. Don't re-derive — forward or backward.

You Can't Cut What You Can't See

Every agent writes local logs, so tracking is always possible. Pick the tracker that reads your agent's logs.

Every cut on the next slide came from this — Headroom cut once device load was measured; the idle graph MCP pruned once its context tax was measured.

Marketing Shows the Pros. These Are the Cuts.

Three layers stack: output (write less) · input (read less) · routing (cheaper provider).

Two Reasons This Isn't Only About Money

"Won't tokens just get cheaper?" Cheaper shrinks factor 1, not factor 3 — a wrong implementation still costs two reviews. And cheaper never meant less: Jevons paradox.

How Did We Get So Poor

Before AI, the funnel only grew: idea → execute → usage, small group to more at every stage. After AI, that funnel flips — everyone ideates, execution and real usage shrink.

The subsidy ending, visualized.

Idea → execute → usage, before and after.

Output ≠ Outcome ≠ Impact

AI's headline effect isn't better decisions — it's more Output (code, summaries, predictions, instantly). But Output, Outcome, and Impact are three different things, and AI only ever hands you the first one:

• Output — the immediate, direct result the model generates: a code snippet, a summarized document, a predictive score.
• Outcome — the observable shift in behavior or process caused by that output: a bug actually stops recurring, a report actually gets acted on.
• Impact — the ultimate business or strategic value that shift produces: lower support cost, higher revenue, a team that ships without burning out.

Ten AI-drafted PRs is Output, verifiable in seconds. Whether they cut defect rates is Outcome. Whether that's a calmer on-call rotation six months later is Impact. More Output doesn't automatically buy more Outcome, and more Outcome doesn't automatically buy more Impact — that gap is exactly where judgment lives.

Checklist

• Plan before you generate — a plan costs hundreds of tokens; a wrong implementation costs thousands, twice-reviewed
• Let something adversarial attack the plan before code exists
• Review your own diff before the PR
• Never let an agent be the sole reviewer of agent-written code; never let it write the tests and the implementation in the same session
• Hard rules in hooks, not prompts — a prompt is a request, a hook is a constraint
• Route by task: cheap tier (Haiku, GLM, MiniMax, Kimi) → mid tier (default) → flagship
• Match the tool to the constraint that binds — local, OpenRouter/OpenCode, or Claude Code/Codex
• CLAUDE.md under ~200 lines; globbed rules for the rest
• Command hooks over prompt hooks for deterministic checks
• Index once (Tree-sitter), query on demand; reuse memory instead of re-deriving it
• Long session? Summarize and start fresh instead of replaying the whole transcript
• Cache structured for the window — static prefix front, dynamic state back, batch inside TTL, stagger your first parallel call
• Mine chat logs and PR review comments for recurring corrections; encode each one once
• Guard background jobs (CPU/memory + dedupe) before running multiple worktrees
• Smallest correct diff, always — it's a discount on every future session, every watt, every dollar