Chatticus records what every model call costs, in dollars, and stores the record inside the session. The workspace shows it by bot, conversation, model and turn, and says when a number is incomplete. This page is exact about what is built and what isn't.
Where this stands today
On our development environment, the cost of the model work is recorded for every model call, whether the turn ran on a serverless worker or on a computer. The record is stored inside the durable session, so it moves with the session.
A balance that counts down tells you how much is left and nothing about what a conversation cost. So we attach dollars to the work, and show them where the work happens.
Recorded. Every model call has its own cost record, stored inside the durable session. A per-turn index summarizes them, and a daily job adds them up for each organization to feed operator budget alerts and the meter that can pause computer work.
Shown. An HTTP API serves the numbers, and the workspace shows them in a Costs tab, a header chip and markers under messages. All of it is available on the development environment.
What you can see
The Costs tab. In the workspace inspector: an organization month summary, breakdowns by bot, conversation and model, and recent turns. Open a turn to see a drill-down that lists each call's model, tokens, cache reads and writes, tier, price book and dollars. CSV download buttons export what's on screen.
Where you're working. A header cost chip shows what the open conversation has cost. Under messages, a Triggered marker shows what a message set in motion and a Took marker shows what a reply used.
The API. An HTTP API returns cost by organization, month, bot, conversation, member, model and turn, with a per-call drill-down, CSV and NDJSON export, and compare endpoints.
Incomplete totals say so. A total that can't count every call reads "at least" the amount, with a note such as "incomplete: 2 unpriced calls".
Unpriced is not zero. A call the price book can't price shows as unpriced. Estimated rows and rows recorded through the model gateway are labelled as such, and a sub-cent amount is never shown as zero.
Not a bill. A standing line in the view says these are model token costs at published list prices, not a bill.
What is written down
Each call gets one record, keyed by the response it belongs to, so it is written exactly once even across retries, crashes and handoffs. A record is the same whether the turn ran on a serverless worker or on the computer. It holds the tokens (uncached input, cache reads, cache writes and output), the model, the price-book version, the tier, and the dollar cost.
A per-turn index sits beside the records. It holds the bot, the channel, the message number and per-model subtotals for the turn, and the views above are built on it. A spoken line is recorded too, because voice understanding is a model call.
How the dollars are worked out
The price book covers gpt-6-luna, gpt-5-nano and gpt-5-mini. It prices cache reads, cache writes and the long-context tier, and it prices each call at the model that served it. Every record names the price-book version it used, so a figure can be traced to its rates.
A model that isn't in the price book is never silently priced at zero, and the model gateway that computers use refuses a model that isn't priced. The rates come from the library's bundled catalog.
Where it stops
The populated view is checked with test data. We checked the populated view with test data and the empty state live. We haven't yet watched it fill with real data in a signed-in workspace, so treat the first real numbers as a check on us.
Rates are not checked against the source. The rates come from the library's bundled catalog. We haven't verified them against the vendor's own page.
Some calls are not metered. Compaction (the model summarizing a long conversation) and aborted calls are not metered.
Service tiers are not modelled. Vendors can bill a call at a different multiplier depending on its service tier. We price at the standard rates and don't apply a service-tier multiplier.
AWS spend is a separate meter. An owner can set a monthly AWS spend ceiling that pauses new computer work when it's passed. It refuses work when it can't read spend, but reading a customer's real AWS spend hasn't been verified end to end, so don't rely on it to cap a bill.
How the computer’s own cost stays low
Not built yet
None of this exists today, and we're not putting dates on it.
Comparison
Sessions side by side
Putting two sessions or two approaches next to each other in the interface, and export polish beyond the CSV and NDJSON files that exist.
Finer grain
Cost for each tool call and each sub-agent
Cost down to each tool call inside a turn, and for each sub-agent when a bot delegates part of its work. Chatticus has no sub-agent tool yet.
Older data
Older ledger rows
Rows recorded before the current record shape moved into it, so history shows up in the same views.
Pricing
Rates checked, tiers applied
Rates checked against the vendor's own page, and service-tier multipliers applied to the calls they apply to.