FinOps for agentic coding

See where agent spend goes — and what it shipped.

TokenPlane is a local FinOps dashboard for Claude Code. It decomposes the cache economics that dominate agentic bills, and ties every estimated dollar to the ticket, commit, and story point it delivered — with the uncertainty labelled on every chart, because a cost tool you can't trust is worse than no cost tool.

Local-first — your telemetry never leaves your machine No signup — a read-only demo, or your own install Honest numbers — estimates say "estimated"

Open the demo Run it on your data

The button opens the hosted demo: synthetic data for a fictional organization, read-only, regenerated every six hours. It runs on a single small server and may be down.

TokenPlane Overview page: KPI tiles for total cost, cost per story point, spend against budget, effective hourly wage, context tax, and an anomaly count, over a strip of session, token and plan-ROI totals. Below them a context-economics breakdown splitting estimated spend into remembering, rebuilding and new I/O, a wage-by-model table, turns-and-spend per model, and top skills by spend. A DEMO DATA tag is visible in the header. — The Overview page, 7-day range. Synthetic demo data — the DEMO DATA tag ships with the product and stays on whenever you're not looking at your own telemetry. That's the house style: the chart never claims more than the data can.

01 — THE COST STRUCTURE

Agentic spend has a cost structure your current tooling doesn't understand.

When an agent works, most of what you pay for isn't new work — it's carrying context: re-reading and re-writing the conversation so the model remembers what it's doing. In the week we spent building TokenPlane, 91.7% of our estimated spend was cache traffic. One project, one developer — your share will differ. The point is that a per-token bill will never show it to you, and TokenPlane makes it a budget line.

It's not just a decomposition — it goes to root cause. When our own cache kept rebuilding while still warm, we traced it to a harness serialization quirk that invalidates the prompt cache after file edits, isolated it to an exactly reproducible token prefix, and measured the damage: ≈$59 of $64 of warm-cache rebuilds in one week, with proposed upstream fixes. The Efficiency page turns findings like that into a ranked savings list — where every estimate that's an upper bound says upper bound.

TokenPlane Efficiency page: a productive-token share score over a red/orange/green context-tax bar, then ranked savings recommendations — avoid warm-cache rebuilds, reduce rejected work, and one counterfactual per performance tier (Frontier spend repriced on deepseek-v4-pro, Advanced on claude-sonnet-5, Workhorse on deepseek-v4-flash), each with an estimated dollar figure, APPROX chips on cross-provider estimates, and a note naming models excluded for having no published benchmark score. — Efficiency, 7-day range, demo data. Note the captions: every savings figure carries its own caveat, and the score explains what it grades before it grades you.

02 — THE DENOMINATOR

Spend tied to units of delivered work — not millions of tokens.

Every engineering leader deploying coding agents gets the same question this year: "what are we getting for this?" Tokens don't answer it. TokenPlane denominates spend in the units the business already uses: cost per commit, per thousand lines of code, per accepted edit, per Jira ticket, per story point, per epic — attributed per turn by a zero-friction hook that reads the ticket key out of your branch name.

And when attribution falls short, it says so. Untracked spend isn't dropped or smeared across tickets — it's a loud red bar with a dollar figure on it. In our own build week, coverage started at 40%, and the page made sure we couldn't ignore it.

TokenPlane Outcomes page: an attribution-coverage bar showing tracked versus untracked spend, a cost-by-epic table with status, points, sessions, turns and spend per point, a cost-per-ticket table adding the primary model per ticket, and a spend-per-story-point tile. — Outcomes, 7-day range, demo data: per-ticket and per-epic cost, story points, and the attribution-coverage bar that keeps untracked spend visible instead of buried.

TokenPlane Allocation page: an unmapped-usage warning naming spend that belongs to no group, ranked spend-by-group and spend-by-user bars, top movers against the previous window, and unit-economics rows showing cost per commit, per KLoC and per accepted edit for each team. — Allocation, demo data: showback by group and user, top movers, and per-team unit economics — including an unmapped-usage warning the page refuses to hide.

If you write the code

Session Metrics tells you why turn 40 cost triple turn 39 and why your cache went cold. Efficiency tells you which habits are expensive. The plan-ROI chip tells you what your subscription is actually worth in API-equivalent terms.

If you sign the bill

Outcomes and Allocation answer the budget meeting: what each ticket and epic cost, what each team spends per commit, and how much spend isn't attributed yet — stated, not hidden. Adoption starts with the engineer; the numbers are for you.

03 — THE CASE STUDY

The product is its own first case study.

TokenPlane tracked the cost of its own construction. Every feature on our board carries its invoice: which ticket, which model, how many turns, how many estimated dollars. The numbers below are from that build week — shown as proof the pipeline works end to end, not as benchmarks.

~$607

estimated list-price LLM spend

commits

~13.8K

lines added

7 pages

shipped in about a week

One project, one developer, one week, priced at list rates nobody actually invoiced. That's a methodology demo, not a study — see below.

METHODOLOGY, NOT BENCHMARK

Our case study

Measuring our own build produced genuinely interesting numbers — including a wide spread in dollars per story point across model tiers. We do not publish that spread as a conclusion, and you should distrust anyone who publishes theirs. It's one project, one developer, n≈11 tickets, and the model assignments were chosen per-ticket in advance — small well-patterned work routed to cheaper tiers, research and integration work to premium ones. The comparison is confounded by design, by our own sensible process.

What the week does prove is the methodology: capture → attribution → per-ticket economics works end to end on a real project, and it surfaces findings a generic cost dashboard can't — the warm-rebuild root cause above came out of it. The pitch is not "our $/point spread." The pitch is that TokenPlane can tell you yours, on your work, at whatever n you accumulate — with the caveats printed on the page.

Captions we actually ship, worn as a badge:

estimated — list price; no invoice exists upper bound — the whole turn is counted insufficient history for a confident projection (unassigned) — unmapped spend, kept loud n is small — do not generalize DEMO DATA

A FinOps product's only durable asset is trust in its numbers. "Estimated" and "recorded" sit side by side and disagree in public (~17% in our week — explained on the tile, not reconciled away). We'd rather underclaim than get one number shredded and poison the rest.

THE PRODUCT

Seven pages, one honest pipeline.

01Overview

The wall clock and the wallet: effective hourly wage, cache ROI, recorded vs estimated cost side by side, context-tax share, and spend over time.

02Allocation

Showback by group and user via a plain YAML mapping, top movers vs the previous window, and unit economics: cost per commit, per KLoC, per accepted edit.

03Efficiency

The productive-token score, the remember/rebuild/new-I/O decomposition, and a ranked savings list where every figure carries its caveat.

04Outcomes

Cost per ticket, story point, and epic, joined to Jira fail-soft — with attribution coverage and untracked spend kept loudly visible.

05Budgets & Alerts

A Budgets page — budget vs actual, a deliberately humble forecast, an anomaly feed, subscription ROI, and a CRUD config tab that writes budgets.json — and a separate Alerts page: session subscriptions plus 80%/100% budget thresholds, delivered as in-app notifications with a header bell.

06Session Metrics

A single session, turn by turn: cost, cache hits and rebuilds, and context-window growth. The page that answers "why was my cache cold?"

07Diagnostics

The pipeline watching itself: capture lag, event counts, schema health. If the numbers upstream are broken, this page says so before you trust a chart.

RUN IT ON YOUR OWN DATA

TokenPlane runs on your machine.

Nothing leaves it: no account, no cloud component, nothing listens outside 127.0.0.1. Design partners get a one-command install bundle for macOS and Windows that captures Claude Code and Codex CLI end to end: ClickHouse and an OpenTelemetry collector in containers, one dashboard binary, and a small hook that attributes each turn to the ticket in your branch name.

The repository is private while the product is pre-release. Request an invitation with your GitHub account and you can download the bundle the same day.

Request an install invitation Open the demo

Tiers

The meter is open source and free: capture, every dashboard page, a single-team install. A licensed self-managed tier adds multi-team governance, SSO and a Helm-deployed stack. A cloud tier, later, is where industry benchmarking lives. Details on request.

Alpha status. Read before you rely on it. This is a pre-1.0 build: interfaces and schemas may change, and the hosted demo runs on a single small server and may be down. Every dollar anywhere in the product is a list-price estimate. On a subscription plan no such invoice exists, and the product tells you so on the page. Capture depends on each client's telemetry stream, which is the vendor's to change. We think the analysis is the interesting part.

The user guide has the full walkthrough: every page's widgets and every metric definition with its caveats.