Awesome AI Tokenomics

A map of what AI tokens actually cost, and where they're wasted vs. well spent.

"I feel nervous when I have subscription left over. That just means I haven't maximized my token throughput."
Andrej Karpathy, No Priors (2026)

As of 2026-07: 190 entries across five areas, 8 practices, 10 concepts, 8 claims, and 7 copy-paste setups.

Contents

• Where to start
• Legend
• Monitor
• Optimize
• Govern
• Understand
• Measure
• Practices
• Concepts
• Claims
• Setups and skills

Where to start

Just want the numbers: the five area sections below hold every entry. Want the method: read the practices first, then the concepts behind them. Building something: setups and skills holds runnable configurations.

Legend

Each entry ends with a kind badge: (blue, with the license when known), or a gray badge for , , , for companies, and . Plain entries are articles. GitHub-hosted tools also carry live star and last-commit badges.

Monitor

Dashboards

• ccusage - A widely adopted open-source CLI that reads local agent logs to report token usage and cost across 15 coding-agent sources, with caching-aware pricing.
• Claude Code Usage Monitor - The most-adopted Claude Code usage monitor: a live terminal dashboard with burn-rate analytics, P90 limit detection, and session-expiry forecasts.
• claude-usage - A local dashboard for Claude Code token usage, costs, and session history; Pro and Max subscribers get a quota progress bar.
• ClaudeBar - A macOS menu-bar app that monitors AI coding quotas across 11 providers; the README declares MIT but ships no license file, so the OSS grant is unconfirmed.
• CodeBurn - An open-source tracker for 36 coding tools whose optimize command flags named harness-waste patterns with dollar estimates it later checks against actuals.
• CodexBar - A free, open-source macOS menu-bar app with a visually clean interface that shows limits and reset timers at a glance across dozens of AI providers, plus credit balances and spending when billing data is available.
• Codex Usage Tracker - A local-first dashboard, CLI, and MCP tools indexing Codex CLI logs into SQLite to show where tokens, credits, and cost go, including cache ratios.
• CodeZeno Usage Monitor - A Windows-taskbar widget showing real-time Claude Code quota and usage at a glance, without opening a terminal.
• Datadog LLM Observability - Cost - Datadog's LLM Observability estimates per-request cost across 800+ models from token counts and public pricing; invoice reconciliation is a separate product.
• gh-aw (GitHub Agentic Workflows) - GitHub's agentic-workflows runtime with first-party per-run token and cost metering, plus budget caps that stop a workflow mid-run.
• Grafana Cloud GenAI Observability - Grafana Cloud's GenAI Observability ships a prebuilt dashboard for LLM cost, token usage, and latency, built on top of the OpenLIT SDK.
• OpenLIT - An open-source (Apache-2.0), OpenTelemetry-native platform with a self-hosted dashboard for LLM cost, token, and latency observability.
• OpenUsage - A native Swift macOS menu-bar meter for 10 AI coding subscriptions, showing session and weekly limits, credits, and estimated spend from local credentials.
• TokenTracker - A local-first token and cost dashboard for 27 coding tools, with a desktop pet, native widgets, and achievements as a distinct gamified take on usage metering.

Ebpf Kernel Capture

• AgentSight - Uses eBPF to watch an AI agent from the kernel boundary, correlating what it said it would do against what it did, at under 3% overhead.
• OpenTelemetry eBPF Instrumentation (OBI) - GenAI / MCP - OBI is OpenTelemetry's zero-code eBPF instrumentation (formerly Grafana Beyla) that captures GenAI and MCP traces at the kernel layer with no SDK.

Observability

• Langfuse - An open-source platform for tracing, evaluating, and analyzing LLM and agent transcripts, with a prompt-management layer on top.

Otel For Llms

• OpenLLMetry - An open-source set of OpenTelemetry-based SDKs and instrumentations, built by Traceloop, for LLM apps.
• OpenTelemetry GenAI Semantic Conventions - OpenTelemetry's GenAI Semantic Conventions define the vendor-neutral token, cost, and cache attribute names that OpenLLMetry and Phoenix both converge onto.

Tracing

• Arize Phoenix - A source-available (Elastic License 2.0) LLM tracing platform recording per-span token counts and USD cost via OpenTelemetry.
• claude-tap - A local trace viewer intercepting API traffic from 14+ coding agents, showing per-request token breakdowns: input, output, cache read, cache creation.
• LangSmith - Cost Tracking - LangSmith is LangChain's commercial LLM/agent observability SaaS.
• Opik - Comet's open-source (Apache-2.0) LLM observability platform, highest-starred in its class, with per-span USD cost estimated from token usage.

Optimize

Caching

• GPTCache - An open-source semantic cache returning a stored LLM response for a paraphrased repeat query via vector search, skipping the paid call.
• khazad - A transport-layer semantic cache for LLM APIs on Redis 8 Vector Sets: it intercepts HTTP traffic with zero application code changes and replays cached responses…
• prompt-cache - A Go LLM proxy that adds a three-tier semantic cache: high similarity hits directly, low skips, and a gray zone runs a cheap verification model to guard against…
• Redis LangCache - Redis's fully-managed semantic cache: a REST API that returns a stored response when a new query is similar to a past one, so paraphrases skip the paid LLM…

Cheap Local Models

• llama.cpp - The foundational open-source (MIT) local LLM inference engine most of the local ecosystem runs on, with an OpenAI-compatible server built in.
• Ollama - The de facto runtime for running open-weight models like Qwen, DeepSeek, and GLM-5.1 locally, shifting inference onto hardware you already own.

Context Engineering

• AgentDiet - trajectory reduction ("Reducing Cost of LLM Agents with Trajectory Reduction") - AgentDiet is an inference-time module that strips useless, redundant, and expired information from an agent's trajectory, without hurting performance.
• Anthropic vendor-native context management (context editing + memory tool + server-side compaction) - Anthropic's context editing, memory tool, and server-side compaction cut token consumption by a vendor-reported 84% in a 100-turn web-search evaluation.
• Claude Code compaction engine - the three-tier mechanism and its cache/correctness failure modes - Claude Code's harness - not the API - decides how to trim a filling context window, and it does this through a three-tier compaction engine.
• Codex CLI compaction cost - over-eager compaction as a token-amplification loop - Upgrading Codex CLI from v0.116 to v0.118 made context compaction fire twice as often, doubling or tripling token consumption for identical tasks.
• Context Mode - MCP server that sandboxes tool output out of the context window - This MCP server sandboxes tool calls and returns only the distilled result, claiming a 98% cut: 315 KB of output down to 5.4 KB.
• Context Rot - LLM performance degrades as input length grows - This is Chroma's controlled study of how LLM output quality changes as input length grows, holding task difficulty fixed.
• ContextBudget - context management as a budget-constrained sequential decision - ContextBudget's BACM method has an agent decide when and how much to compress its history based on remaining context budget, not a fixed rule.
• Cursor vendor-native context management - dynamic context discovery + Composer self-summarization - Cursor's dynamic context discovery loads tool schemas and large outputs on demand instead of eagerly, a change the vendor reports cut context usage by 46.9%.
• headroom - the context-compression genre's mega-anchor (quality story dissected) - An Apache-2.0 context-compression tool for LLM/agent pipelines, the category's largest repo, confirmed organic by star-forensics.
• Karpathy's LLM Wiki - Andrej Karpathy's LLM Wiki pattern has an agent build and maintain a persistent markdown wiki from your sources, instead of re-retrieving raw files.
• LLMLingua - Microsoft's prompt-compression library that uses a small model to drop low-information tokens before a prompt reaches the target LLM.
• llmtrim - A local proxy that compresses a coding agent's prompt, tool schemas, and history before forwarding, and can reroute Claude calls to Grok.
• Minification of state-in-context agents - the clean waste-vs-capability datapoint - This ICPC 2026 study found that minifying code in a coding agent's context cuts input tokens by 42% but costs 12 percentage points of accuracy.
• Repomix - Packs an entire repository into a single AI-friendly file, reporting token counts and using Tree-sitter to compress code to signatures only.
• rtk - the context-compression genre's largest adoption anchor (reduction-only headline) - rtk is a single-binary Rust CLI proxy that intercepts and compresses the output of common dev commands before it reaches an LLM coding agent's context window.
• RULER - the "real context size" long-context benchmark - NVIDIA's RULER benchmark found that of models claiming 32K+ token context windows, only half actually maintain quality once you fill them to 32K.
• Self-Compacting Language Model Agents - This paper introduces SELFCOMPACT: instead of fixed-interval summarization, the model itself decides when and how to compress a growing agent trace.
• Serena - An open-source (MIT) MCP toolkit that gives a coding agent IDE-grade semantic code retrieval and editing: 'the IDE for your coding agent'.

Cost Controls

• Harness-side runaway-loop cost guardrails (Claude Code + Codex, July 2026) - In mid-July 2026 both dominant coding CLIs shipped first-party guardrails against runaway agent loops within days of each other.

Gateways And Proxies

• Bifrost (Maxim AI) - Bifrost is a Go-based AI gateway fronting 1000+ models that measured just 11 microseconds of added latency per request at 5,000 requests per second.
• Cloudflare AI Gateway (Spend Limits) - Cloudflare AI Gateway is an edge-native LLM proxy that added dollar-denominated spend limits in June 2026, blocking or rerouting requests once a budget is hit.
• Helicone - An open-source (Apache-2.0) LLM proxy that logs every request's cost, latency, and tokens in one line of code; Mintlify acquired it in March 2026.
• Kong AI Gateway - The AI layer of Kong's API-gateway platform: a proxy that meters LLM/agent/MCP traffic for billing, showback, and chargeback.
• LiteLLM - An open-source gateway fronting 100+ LLM APIs that computes real per-request dollar cost from a live pricing map, with spend limits.
• OpenRouter - A unified API gateway fronting 400+ models across 70+ providers that auto-routes each request by price, with fallback on outages.
• Portkey AI Gateway - Routes LLM traffic across providers and enforces hard USD budget limits on virtual keys, auto-expiring a key once its cap is hit.

Memory

• claude-code-memory-setup - A practitioner recipe pairing an Obsidian memory vault with a local AST code-graph tool; the author self-reports up to 71.5x fewer tokens per Claude Code…
• claude-mem - A coding-agent observational-memory layer that captures every session, compresses it with AI, and re-injects relevant context next time; self-reports ~10x token…
• LangMem - LangChain's long-term memory library: it extracts and consolidates facts from conversations and integrates natively with LangGraph's memory store, so agents…
• Letta (MemGPT) - The MemGPT lineage project: a platform for stateful agents that pages an LLM's context like an OS, keeping working memory small and moving the rest to archival…
• Supermemory - A memory and context engine that self-reports 95% recall on LongMemEval while adding only ~720 tokens of context, a claimed 99.4% context reduction versus full…
• Zep / Graphiti - A memory platform for agents built on temporal knowledge graphs; it self-reports serving benchmark answers from a few thousand tokens of retrieved context… (also: Graphiti (OSS engine) · zep repo)

Multi Agent Overhead

• Framework orchestration overhead (the manager-LLM tax) - Hierarchical frameworks like CrewAI add a manager-LLM delegation tax, an extra model that plans and validates, though its cost is unquantified in any primary.
• SupervisorAgent - "Stop Wasting Your Tokens" (runtime supervision) - SupervisorAgent is a lightweight, modular framework for runtime, adaptive supervision of multi-agent systems.

Prompt Agent Loop

• LOOP Skill Engine - LOOP records an agent's first run of a repetitive task with full LLM reasoning, then replays the extracted tool-call template without calling the LLM again.
• Orchestrator-worker model tiering (frontier plans / cheap executes) - A capable model plans while cheaper agents execute; the pattern now ships as a vendor default, hitting 89.7% of LLM quality at 4% of the cost.
• token-ninja - Intercepts deterministic commands like git status or npm test before they reach the model, running them locally and skipping the LLM call.

Prompt Technique

• TOON (Token-Oriented Object Notation) - TOON is a compact, human-readable, lossless serialization of the JSON data model, designed for LLM input.

Retrieval Memory

• Cognee - An open-source (Apache-2.0) AI-memory platform giving agents persistent memory via a self-hosted knowledge graph, via remember/recall/forget.
• Mem0 - An open-source memory layer that extracts salient facts from conversations and retrieves only the relevant ones per call, not the full history.

Retry And Reliability

• Claude Code v2.1.199 - transient-retry hardening & partial-output preservation - Claude Code v2.1.199 now auto-retries rate-limit errors with backoff and raised the default retry ceiling to 300, up from a prior cap of 15.

Routing Model Selection

• Claude Code via a LiteLLM gateway (cheap-tier-in-front setup) - Pointing Claude Code's ANTHROPIC_BASE_URL at a local LiteLLM proxy lets cheaper or non-Anthropic models absorb work the frontier model would otherwise bill for.
• Cluster, Route, Escalate - cost-aware cascaded serving - This paper proposes a two-stage cost-aware cascade for LLM serving that combines routing and escalation into one framework.
• Distilling agent behavior into small task-specific models - Distilling a large agent's behavior into a small 0.5-3B model lets most of its work run at a fraction of the frontier model's per-token cost.
• MTRouter - per-turn cost-aware routing with history-model joint embeddings - MTRouter picks a different model for each turn of a multi-turn conversation, rather than one model per query, to hit a cost budget without losing quality.
• Not Diamond - Not Diamond's meta-model predicts, per input, which LLM will give the best answer at the lowest cost, then routes the request there.
• OpenCode - open-source coding-agent CLI with explicit cost-tier routing - OpenCode is an open-source (MIT) coding-agent CLI with its own explicit cost- and model-routing configuration, set directly in config.
• OrcaRouter - production LinUCB bandit router (hybrid offline-online) - OrcaRouter is a production LLM router built on a LinUCB bandit, with its cost/quality tradeoff independently confirmed on the RouterArena leaderboard.
• RouteLLM - LMSYS's open-source router sending each query to a cheap or expensive model based on a trained cost threshold, as a drop-in server.
• ruflo (formerly Claude-Flow; npm claude-flow v3.17.0) - agent meta-harness with cost-adjusted model routing - ruflo is the leading open-source agent meta-harness for Claude Code and Codex, providing swarm orchestration and persistent memory.
• vLLM Semantic Router - Sends routine queries to cheap or local models and hard ones to stronger backends, as an open-source, self-hostable router.

Serving Inference

• RLM-Cascade - response-level speculative decoding at the gateway - RLM-Cascade, from a PayPal team, has a cheap draft model answer first and an Opus 4.8 verifier accept or rewrite it, at roughly 2% of Opus's cost.
• SGLang - A high-performance serving framework for large language and multimodal models.
• vLLM - The canonical open-source LLM serving engine, using PagedAttention to manage KV-cache memory in blocks so more requests batch at lower cost.

Test Time Compute

• Stop When Reasoning Converges - Reasoning models often keep generating steps after a solution has already stabilized, wasting tokens and adding latency - what this paper calls "overthink.".
• When more reasoning hurts - the test-time-compute ceiling - Two 2026 papers found giving a model more reasoning budget makes it perform worse and cost more; past a point, tool delegation wins outright.

Tool Protocol Overhead

• Code execution with MCP (Anthropic) - Anthropic proposes agents call MCP servers by writing and executing code instead of a tool call per step, so unused tool schemas skip the context window.
• MCP Tool Descriptions Are Smelly! - This study found poorly-written MCP tool descriptions measurably hurt agent efficiency, using an LLM-jury scanner and an A/B protocol on MCP-Universe.
• Tool Attention Is All You Need - MCP re-sends every tool's full schema on every turn, whether or not the agent needs it - a protocol tax known as the MCP/Tools Tax.

Govern

Allocation Chargeback

• CloudZero - An established commercial cloud and AI cost-intelligence / FinOps platform that brands itself 'The AI ROI Company'.
• JetBrains AI moves business plans from monthly licenses to 12-month credits - JetBrains is moving business AI from monthly per-seat licenses to 12-month reallocatable credits plus a governance dashboard; personal Pro/Ultimate prices are…
• Mavvrik (fmr. DigitalEx) - Mavvrik is an AI/hybrid-infrastructure cost governance and FinOps platform, rebranded from DigitalEx in February 2025.
• Pay-i - An SDK-based GenAI cost-observability platform that tracks token-level spend per call and rolls it up into cost-center allocation across orgs and apps.

Anomaly Detection

• Denial-of-Wallet / token-exhaustion attacks - Denial-of-wallet attacks exploit pay-per-token pricing to inflate a bill, via stolen-credential LLMjacking or agents steered into runaway token use.
• Governance Decay - compaction silently erasing safety/governance constraints - Compacting an agent's context can silently erase governance rules: across 7 model families, violations rose from 0% to 30%, up to 59% for some.

Billing Audit Finops

• FinOps for AI - canonical practitioner framework for governing AI/LLM spend - FinOps for AI is the FinOps Foundation's official practitioner framework for governing AI, GPU, and token spend.
• Vaudit - TokenAudit (LLM invoice reconciliation / AI spend audit) - Vaudit is an AI-native, independent spend-auditing and recovery platform (San Francisco, founded late 2023).

Budgets Caps

• AEGIS - An open-source (MIT) pre-execution firewall and cryptographic audit layer for AI agents.
• Claude Code's 5-hour/weekly usage quotas - Anthropic has stopped publishing exact numbers - Anthropic stopped publishing exact Claude Code usage quotas, describing Max plans only as 5x/20x multipliers of Pro with no absolute numbers.
• TrueFoundry (AI Gateway - Budget Limiting) - TrueFoundry is an enterprise GenAI deployment/gateway company founded by ex-Meta founders.

Energy Carbon

• CodeCarbon - An open-source (MIT) library for estimating a workload's energy use and CO2e emissions, and ML's widely-cited carbon baseline.
• EcoLogits - energy/carbon of LLM API calls (the hosted-usage estimator) - Estimates the energy and carbon footprint of calling generative-AI APIs: the hosted counterpart to CodeCarbon, which measures your own hardware.
• Epoch AI - how much energy a query uses (the per-token energy anchor) - Epoch AI built a transparent, first-principles estimate of how much energy one LLM query costs.
• Google - measuring the environmental impact of AI inference (provider disclosure) - Google published a first-party disclosure of the energy, carbon, and water cost of a median Gemini Apps text prompt, authored by Amin Vahdat and Jeff Dean.
• ML.ENERGY Leaderboard v3.0 - measured inference energy (the "reasoning ≈ 25× energy" signal) - Version 3.0 of this leaderboard measures real GPU inference energy across 46 models x 7 tasks, finding reasoning models use roughly 25x the energy of others.

Policy Enforcement

• ActPlane - An eBPF-based, OS-level policy-enforcement engine for AI-agent harnesses like Claude Code and Codex.
• MCPGuard-Dynamic - Meta's open-source kernel-level eBPF sandbox built specifically for MCP.

Spend Management

• ChatGPT Enterprise - usage analytics & spend controls - OpenAI's first-party spend layer for ChatGPT Enterprise/Business: a Global Admin Console with credit caps, request workflows, and a Cost API.
• Claude Enterprise - admin analytics & cost controls - Anthropic's first-party spend surface for Claude Enterprise/Team admins: org-level spend caps, model defaults, and per-user cost analytics via the Admin API.
• PointFive (AI Efficiency OS / TokenShift) - PointFive's TokenShift governs coding-agent token spend across Claude Code, Cursor, Codex, and more, claiming a 10-20% cut across 11 partners.
• Revenium - runtime AI economic control / spend management - Revenium tracks AI agent spend at runtime to the cent, attributing every model call and tool cost to its workflow, with auto-shutoff on runaway budgets.
• Vantage - A FinOps platform ingesting native token-level cost data from Anthropic and OpenAI's own usage APIs, plus Cursor and cloud spend.
• Vercel AI Gateway - per-API-key budgets - Vercel AI Gateway lets you cap spend per API key in dollars (min $1) with a daily/weekly/monthly refresh, rejecting further requests once the cap is hit.

Understand

Buyer Incentives

• Claude "subscription arbitrage" and its (announced, then paused) end - Users route agentic workloads worth far more than a subscription's price through cheap Pro/Max plans; Anthropic tried to close this, then paused the fix.
• Coding-agent native spend controls (2026) - Within six weeks in 2026, Cursor, GitHub Copilot, and OpenAI each shipped native admin spend controls: budget caps, credit metering, usage dashboards. (also: GitHub Copilot · OpenAI)
• GitHub Copilot metered-billing bill-shock - the demand-side reaction ("tokenpocalypse") - GitHub's move from flat-rate Copilot plans to metered AI Credits exposed agentic workflows' true per-token cost and triggered a mass bill-shock backlash.
• Lanai - Lanai's AI @ Work platform discovers every sanctioned and shadow AI workflow across an org and maps its token spend to the KPIs it actually drives.
• State of FinOps 2026 - AI spend management is now the norm - This is the FinOps Foundation's sixth annual State of FinOps survey, the practitioner census of how organizations manage cloud and AI spend.
• The "$47k Claude Code bill" - the anchor bill-shock anecdote and its mechanistic debunk - A viral $47,000-in-90-days Claude Code bill story was debunked by a teardown pinning the real driver on quadratic context re-ingestion, not runaway use.
• Uber caps AI-coding spend at $1,500/mo per tool after burning its budget in ~4 months - Uber capped AI-coding spend at $1,500 per employee per tool after burning its entire annual budget in roughly four months of encouraged maximal use.

Compression Efficacy

• JetBrains independently measured two token-saving skills against their own claims - JetBrains independently A/B-tested two token-saving skills: rtk ran +7.6% more expensive at low effort (claimed 60-90% cut), Caveman saved ~8.5% (claimed 65%). (also: Caveman A/B post)
• Token-saving plugins are mostly a stupid idea (Tura benchmark) - A benchmark of token-saving plugins found one actively worse than none: cost up 7.2%, tokens up 13.2%, because it broke an already-cached prompt prefix.

Consolidation

• Cisco acquires Galileo (LLM eval/observability) → folded into Splunk Observability - Cisco acquired Galileo, an LLM/agent evaluation and observability platform, folding it into Splunk Observability Cloud's AI Agent Monitoring.
• Tokenomics Foundation (Linux Foundation + FinOps Foundation) - The Linux Foundation is launching the Tokenomics Foundation to build open standards for AI token spend, extending FOCUS to cover token-based costs.

Market Competitors

• Amp (Sourcegraph) - pay-as-you-go, no-markup pricing + mode-based routing - Amp, Sourcegraph's coding agent, passes through LLM cost with zero markup for individuals and teams, with a cost/capability mode: Deep, Smart, or Rush.
• Factory (droids) - subscription pricing + $150M Series C at $1.5B - Factory prices its Droids agents as flat subscription tiers ($20/$100/$200/mo) with usage-based rate limits, not per-token metering, after a $150M round.
• Gemini CLI retirement → Antigravity CLI (open-source coding agent closes, pricing restructures) - Google retired the open-source Gemini CLI on 2026-06-18, pushing users onto closed-source Antigravity CLI and $100/$200-per-month paid tiers.
• OpenHands - MIT OSS coding agent, free local + free cloud tier, at-cost LLM option - An MIT-licensed open-source coding-agent platform with a free local mode, a free cloud tier, and an at-cost LLM pricing option.

Market Sizing

• Gartner - worldwide AI spending forecast: $2.59T in 2026 (+47% YoY) - Gartner's latest forecast puts worldwide AI spending at $2.59 trillion in 2026, up 47% year-over-year, with infrastructure over 45% of the total.
• Menlo Ventures - enterprise generative-AI spend $11.5B → $37B (2024→2025) - Menlo Ventures found enterprise generative-AI spend hit $37B in 2025, up 3.2x from 2024, with coding tools the largest application category at $7.3B.

Model Economics

• "Qwen 3.6 27B is the sweet spot for local development" - Migdał / Quesma (first-party) - Piotr Migdał's #1-on-Hacker-News essay argues Qwen3.6-27B (dense) is the first local model good enough for real coding instead of a metered cloud API.
• Artificial Analysis - Coding Agent Index (tokens & cost per task, model × harness) - This benchmark scores full model-plus-harness stacks, spanning $0.27 to $11.80 per task: a roughly 44x range at similar quality, per Artificial Analysis.
• Artificial Analysis - Intelligence Index + Blended Price (intelligence-per-dollar leaderboard) - Artificial Analysis's Intelligence Index plots a 0-100 capability score against blended price per million tokens, live across 85-122 base LLMs.
• Kimi K2.6/K2.7-Code and GLM-5.2 official API pricing - Kimi K2.7-Code ($0.95/$4.00 per million tokens) and GLM-5.2 ($1.40/$4.40) both undercut Claude Sonnet 5 and GPT-5.5 on raw price by 2-5x.
• Local / open-model economics for coding - state of the field (2026) - Open-weight coding models now score 77-81% on SWE-bench Verified, within a few points of closed frontier models, reshaping self-host-vs-API math.
• OckBench - measuring token efficiency / verbosity of LLM reasoning - OckBench answers a specific tokenomics question: which model burns the most tokens for the same answer?
• Reasoning-token billing across providers - the hidden output multiplier - Every major AI provider bills a model's hidden reasoning tokens at the most expensive output rate, without ever returning them to the caller. (also: Google · DeepSeek)
• Reasoning-token consumption behavior - length ≠ effort, and verbosity is a separate lever - Chain-of-thought can burn about 258 tokens on problems a direct answer solves in 15 (roughly 17x overhead), and simple agentic steps trigger it by accident.

Pricing Models

• Batch / Priority / Flex service tiers - the scheduling axis of token pricing (clustered, cross-vendor) - Every major LLM vendor sells the same lever, trading latency for price via async batch scheduling, with Anthropic, OpenAI, and Google all near 50% off. (also: OpenAI · Google)
• Bessemer - the AI pricing & monetization playbook (seat → usage → outcome) - Bessemer's playbook argues AI pricing is shifting from per-seat to consumption/outcome-based, citing Intercom's $0.99-per-resolved-ticket model.
• Cached-input discounts - the ~90%-off lever behind cache-accounting - Cache-read pricing discounts input tokens by about 90%: the biggest lever on an agentic bill, since input is roughly 85% of session cost.
• ChatGPT subscription tiers and Codex CLI bundling/pricing (2026) - OpenAI bundles Codex CLI into every ChatGPT tier from Free through the new $100/mo Pro plan, differing only by rate-limit multiplier.
• ChatGPT workspace-agent credit billing (effective July 6, 2026) - OpenAI ended the free preview for agent runs invoked inside ChatGPT Business, Enterprise, Edu, and Teachers on 2026-07-06.
• Cursor charges by tokens, split into first-party and third-party pools - Cursor meters by tokens per million (input/output/cache-write/cache-read), split into a first-party pool and a third-party API pool, with a $0.25/M Teams… (also: Teams pricing blog)
• Devin's Agent Compute Unit has no published definition of what it meters - Devin bills Enterprise usage in Agent Compute Units, but no official doc defines what an ACU measures (not tokens, seconds, or calls); the opacity itself is the…
• Fable 5 leaves subscription inclusion - frontier tier moves to usage-credit metering (July 7 cliff) - Anthropic is moving Fable 5 off subscription-included access onto usage-credit metering, with the cliff date slipped twice, now set for 2026-07-20.
• Google AI Pro price and Gemini/Antigravity free-tier limits (2026) - Google AI Pro is confirmed at $19.99/month, beneath the $99.99 and $199.99 AI Ultra tiers giving higher rate limits on the Gemini API and Antigravity.
• GPT-5.6 family (Sol / Terra / Luna) - API pricing - OpenAI's GPT-5.6 family prices three tiers 2x apart: Sol at $5/$30 per million tokens, Terra at $2.50/$15, and Luna at $1/$6.
• LiteLLM flex/priority service-tier cost keys - the harness-level tier-routing lever - LiteLLM automatically prices requests made at a non-standard tier like flex or priority, applying the right discounted or premium rate automatically.
• LLM price decline + Jevons paradox - unit price crashes, total spend climbs - Per-token prices are falling roughly an order of magnitude per year, while total AI spend rises even faster.
• LLM token pricing dimensions - the structure of a token bill - This maps out how frontier LLM APIs meter and price tokens, read straight off the two largest providers' pricing pages, Anthropic and OpenAI.
• OpenAI is winding down the self-serve fine-tuning API and platform - OpenAI is winding down self-serve fine-tuning because prompting got cheaper and more capable than fine-tuning for most uses, cutting off customers by 2027.
• Tokenization multiplicity & overcharging - the pay-per-token integrity problem - Two academic papers show the same output can be billed a different token count depending on tokenization, and providers can be incentivized to inflate it.
• Windsurf became Devin Desktop and switched credits to token-based quota - Windsurf became Devin Desktop and in March 2026 swapped opaque per-model credit multipliers for token-based quota where free models cost nothing; a…

Reliability Sla

• Reserved-capacity reliability economics (Azure PTU · AWS Bedrock MU) - Azure's Provisioned Throughput Units and AWS Bedrock's Model Units both let buyers reserve guaranteed capacity, billed hourly whether or not it's used.

Unit Economics

• Cloud Capital - gross margin in the age of AI (the vendor/supply side) - AI-native software runs at roughly 50-60% gross margin versus 70-80% for SaaS, since inference and compute became a large, variable cost of goods sold.
• Cost-of-Pass - an economic framework for evaluating language models - Cost-of-Pass defines the expected dollar cost of one correct answer as inference cost divided by success rate, pricing benchmark accuracy directly.
• DORA 2025 - AI as amplifier, and the delivery-stability tension - Google's DORA program found that as AI adoption becomes universal, delivery throughput rises but so does instability: AI as an amplifier, not a pure win.
• Faros - "The Acceleration Whiplash" (AI Engineering Report 2026) - This is the load-bearing "velocity has a hidden bill" study: telemetry from 22,000 developers across 4,000 teams over two years.
• getDX - AI coding assistant pricing & ROI guide (2026) - Typical AI coding tools cost $200-600 per engineer monthly in seat plus token spend, per getDX, for a median 7.76% PR gain: below vendors' claimed 3-10x.
• METR - measured vs perceived AI productivity (the RCT) - METR's controlled trial found developers took 19% longer to finish issues when allowed to use AI, while still believing it had sped them up by 20%.

Measure

Benchmarks Evals

• Claw-SWE-Bench - Found that adapter/harness design alone swings an agent's Pass@1 score by about 54 percentage points on the identical model backbone.
• Coding Benchmarks Are Misaligned with Agentic SE (Tessl) - A position paper from Tessl (London, UK) argues that today's coding benchmarks don't measure what people think they measure.
• Deterministic Anchoring - how much static structure do code agents need? - This ISSTA 2026 paper found injecting static-analysis facts as plain-text comments raises a code agent's Pass@1 by 3.4pp and cuts trajectories by 1.6 rounds.
• GitHub Copilot agentic-harness efficiency evaluation (first-party offline ablation) - GitHub's own benchmark plots Copilot's agentic-harness resolution rate against dollar-cost-per-task across five benchmarks and four frontier models.
• Harness-Bench - Holds the task, model, and budget fixed while varying only the agent harness, across 5,194 trajectories spanning 6 harnesses and 8 models.
• LoCoMo - Snap Research's very-long-term conversational-memory benchmark; the canonical dataset that Mem0, Zep, and Supermemory all cite, kept as a background instrument…
• LongMemEval - The peer-reviewed (ICLR 2025) benchmark for long-term memory in chat assistants; the standard eval that mem0, Zep, and Supermemory all self-report their…
• MemoryBench - A pluggable harness to run memory systems (Supermemory, Mem0, Zep) head-to-head across datasets like LoCoMo; useful for standardizing comparison, but built by…
• Prompt Compression in the Wild - the end-to-end referee for compression - This ECIR 2026 study found LLMLingua's compression yields up to 18% speed-up only in a narrow window; outside it, the compression step cancels the gains.
• promptfoo - An open-source CLI/CI harness for testing LLM prompts and agents that records per-eval token usage and cost as an assertable metric.
• RedundancyBench - can anyone even detect a redundant step? - RedundancyBench is a benchmark for step-level redundancy detection in agent trajectories - can a model even spot the wasted step in an agent's history?
• RouterArena - the open benchmark + live leaderboard for LLM routers - RouterArena is an open evaluation platform and live leaderboard for LLM routers - systems that auto-select a model per query.
• SWE-Effi - cost-aware re-ranking of SWE-agents under resource budgets - SWE-Effi re-ranks popular AI issue-resolution systems on a SWE-bench subset by cost-under-resource-constraints instead of by accuracy alone.
• Terminal-Bench - The canonical benchmark for AI agents in real terminal/CLI environments, with 89 tasks each vetted through ~3 reviewer-hours.

Cache Accounting

• Gemini context caching - the per-hour storage meter (the third-vendor axis) - Among major providers, only Gemini bills a per-hour storage meter for explicit prompt caching, making a cache a rented line item that accrues cost while it sits…
• LMCache - KV-cache reuse layer with token-level cache-hit accounting (self-host) - LMCache is a self-hosted KV-cache layer beneath vLLM, giving token-level cache-hit observability for teams who own their GPUs, not a hosted bill.
• OpenAI prompt-caching cached_tokens accounting - This is the measurement substrate for prompt-cache savings on the OpenAI API.
• OpenAI Responses conversation state - you pay for the whole chain every turn (and the compaction levers) - This entry covers the billing semantics of stateful conversations on OpenAI's Responses API, plus the two server-side compaction levers that mitigate them.

Cost Anatomy

• Anthropic bill anatomy - the whole-bill line-item taxonomy - This is the canonical enumeration of every meter on a Claude API bill, read live from Anthropic's pricing page.
• TensorZero - cross-vendor token-count divergence ("stop comparing $/M tokens") - The same input can produce 2.65x more tokens on one tokenizer than another's: Claude Opus 4-7 runs 1.57x-2.65x more tokens than GPT-5.4 on the same content.
• Vision-token pricing formulas across the big three - Anthropic, OpenAI, and Google each convert an image into billed tokens with a different formula, so no single cross-vendor image-cost number exists. (also: OpenAI · Google)

Harness Overhead

• Claude Code system prompts (Piebald extraction) - Piebald AI extracts Claude Code's full compiled prompt payload per release: 515 prompt strings and 27 tool descriptions at v2.1.212, each priced in tokens.
• Claude Code vs OpenCode token overhead (Systima study) - Systima measured harness scaffolding overhead before a prompt is even read: Claude Code carries about 32,800 tokens versus OpenCode's 6,900, a 4.7x gap.

Metering

• Cross-vendor coding-agent usage trackers (AgentsView · caut) - AgentsView and caut are open-source tools that read local session logs to aggregate token usage and cost across roughly 20 coding-agent vendors.
• How Do AI Agents Spend Your Money? - This Stanford study is the first systematic look at token spend in agentic coding, running 8 frontier models on 500 SWE-bench Verified tasks.
• tokview - A local, zero-config proxy showing a coding agent's token spend by session, model, and tool call, flagging re-sent results that multiply the bill.

Transcript Analysis

• Early Diagnosis of Wasted Computation in Multi-Agent LLM Systems (Failure-Aware Observability) - This live waste-detection framework for multi-agent systems found that 58.1% of tokens in failed runs are spent after its first warning fires.
• Faros AI - "Token Intelligence" / Token Attribution Ledger - Faros AI is an enterprise engineering-intelligence SaaS (DORA/SPACE-style productivity analytics).
• token-optimizer (alexgreensh) - per-session $ waste-detection plugin, semi-cross-vendor - token-optimizer is a coding-agent plugin that runs eleven heuristic waste detectors per session and prices the flagged tokens in dollars.

Whole Bill Accounting

• FOCUS 1.4 - the cross-vendor billing-data normalization standard (now with invoice reconciliation) - FOCUS 1.4, the Linux Foundation's billing-data schema, added Invoice Detail and Billing Period datasets to reconcile spend against real invoices.

Practices

Tool-agnostic, evidence-grounded standards for token-efficient agentic coding. Each is one page: TL;DR, claim, evidence, links. Browse the practices.

Concepts

Short reference notes explaining the ideas behind the practices: cache economics, the harness-waste taxonomy, orchestration economics. Browse the concepts.

Claims

Confidence-scored beliefs, clearly labeled as beliefs rather than facts, each with its strongest evidence linked. Read the claims.

Setups and skills

Runnable, validated Claude Code and Codex configurations and skills for token-efficient agentic coding, each labeled with how it was validated. Browse the setups.

---

Text content: CC-BY 4.0 (LICENSE) · Code and configs: MIT (LICENSE-CODE). Maintained by the team at Quesma.