How we run a tokenomics assessment.

Can every dollar on the invoice be traced to a job, a team, and what it bought? Every later figure depends on it.

How we read itReconcile tagged spend to the invoice; attribute the untagged tail by who owns the keys and by log volume. Many AI-native teams meter nothing below the invoice line, so coverage is the first gap to close.

FixesUnlocks every other lens, plus per-customer margin & pricing.

Does the setup know the price of one delivered unit — a resolved ticket, a completed task — and is that price tracked and used?

How we read itJoin usage to outcome events; where the join is missing, stand up a feature-level proxy and mark it modelled. Set unit cost against the outcome's value to read headroom or alarm.

FixesOutcome-priced billing, invest / retire calls, a margin-aware roadmap.

How long a cost spike lives before anyone notices — a prompt edit that triples context, a retry storm, an agent that forgets to stop.

How we read itWalk the last quarter for step-changes and, for each, separate when it began from when it was caught. If the record is silent, we stage a controlled spike and see what fires.

FixesCost alerts, per-key ceilings, cost-diff checks at deploy.

Whether each job runs on the cheapest model that still clears its quality bar — proven by replaying its own traffic. Top-tier to small pricing spans 10–25×; most extraction and classification never needed the top rung.

How we read itTake a representative slice of the job's own prompts and run it down an ordered set of models, cheapest first. Fire each a fixed number of times and grade every result against your own production output. Stop at the first one that holds. Anything that clears nothing goes to human review with its evidence.

FixesStatic remapping — the highest-yield, lowest-effort move — then smaller custom models for narrow high-volume work.

Whether the setup routes by difficulty — cheap model first, escalate only what fails — or sends everything to one tier regardless of how hard the request is.

How we read itFrom the right-sizing tests, isolate jobs where a cheap model passes most of the time but not always — the cascade candidates. Model the blended cost of cheap-first-plus-escalate against the flat-flagship baseline, and price the difference.

FixesConfidence cascades, verifier-gated escalation, provider-fallback routing.

The shape and reuse of everything sent into the model. A stable prompt prefix can be re-read by the provider at up to a ~90% discount, so what matters is how much of each call is reused rather than freshly billed. Agent workloads run 100:1–300:1 input-to-output because the full context is resent every turn — which makes reuse the main lever.

How we read itRead cached-vs-fresh input straight from provider usage; analyse sampled templates for the reuse ceiling and the cache-breakers — volatile data spliced ahead of stable scaffold, tool lists that reorder, per-session IDs in the system prompt. Price the distance to the ceiling at the cached rate.

FixesStatic-prefix restructuring, cache-TTL tuning, an app-level semantic cache.

Control on the expensive side. Generated tokens price at 5–6× input, and reasoning tokens bill as output — often at a high default nobody set on purpose. The most common overspend we find.

How we read itAudit request settings at every call site in code, joined to trace data. Compare what the model produces to what the downstream code consumes — three parsed fields don't need a paragraph wrapped around them. Inspect reasoning settings explicitly; unset or defaulted-high is where it leaks.

FixesOutput ceilings, structured outputs, per-class reasoning budgets, terser prompts.

Tokens consumed per completed task inside agent loops, where each turn re-sends the whole conversation and tool output so far. It's the fastest-growing line in most setups: a ten-turn task can cost ~50× a single call, and trimming stale context alone recovered ~84% in a published 100-turn evaluation.

How we read itRebuild each loop from grouped traces and measure what fills the window turn by turn — instructions, tool schemas, history, results. Surface the usual offenders: full schemas resent for a two-tool task, multi-KB dumps never read again, no compaction, no stop condition.

FixesTool-result trimming, scheduled compaction, sub-agent isolation, loop budgets.

Whether you pay list price when you need not. Discounts already on the table — batch and flex tiers (a slower lane, roughly half price, for work no user is waiting on), caching, volume commitments — frequently go unclaimed. Prices fall ~10×/year at a fixed capability, so a routing choice two quarters old was made against a price sheet that no longer exists.

How we read itSize the eligible discount per class from the inventory, classify each job by how long it can wait, and price async volume stuck on the realtime tier at the flat ~50% recovery. Then find who owns the re-pricing cadence — usually no one.

FixesBatch / flex migration, commitment negotiation, a refresh cadence tied to releases.

Money on calls that returned nothing usable — hard failures, re-parse retries, duplicate submissions, double-completed timeouts.

How we read itRead status codes, retry headers and near-identical prompts in tight windows from gateway logs, then attribute cause — re-parse loops point at missing structured output, 429 bursts at absent backoff, duplicates at missing idempotency. A well-run setup sits in the low single digits.

FixesStructured outputs, idempotency keys, jittered backoff, circuit breakers.

Whether spend has hard stops — per-key and per-team ceilings, rate limits, a kill-switch that fires — and whether anyone owns the page when one trips.

How we read itAudit gateway and provider config, then prove it — drive a test key into its limit and confirm the block, rather than trusting the setting. Ask who got paged the last time a ceiling tripped, and what happened next.

FixesEnforced per-key ceilings, dev / prod key separation, per-job spend targets.