Dodaios In September we used Dodaios to build Dodaios, all day, most days. If you price every token of that month the way the AI providers price their APIs, the work was worth $15,224.
Our API keys were billed $216.65. And $189.45 of that came from one coding agent that runs on our own key, most of it in a single evening.
The other $15,007 ran on flat monthly plans, and Dodaios still prices every token of it. This post covers where you see those numbers in the app, how a token becomes a price, what all those tokens actually were, and what broke while we taught Dodaios to count. In this post, “we” means the people building Dodaios and the coding agents that do much of the typing.
Where you see it
Everything below comes from one place in the app: Settings → Activity → Spend, a section called Spend & Tokens. The same section runs live on the “Spend” monitor in Mission Control, the room for the whole agent fleet in the Dodaios Verse office.
The month at a glance: $16,302 worth of work, $217 of it billed
Spend & Tokens, last 30 days, as it looked on October 1.
The controls are the whole story in small. The range picks 7, 30 or 90 days or everything. The area switch narrows the numbers to the assistant, its voice, or the Agentic IDE. The billing switch is the important one: Billed to keys shows money that actually left an API key, On subscriptions shows work done on a flat plan, and All shows both. Dollars can be shown in euros at a fixed exchange rate.
Two numbers for every day
Every call Dodaios records gets two answers: what it would cost through the provider’s API, and whether that money was actually billed. Work on a subscription, such as a Claude Code or Codex login, is not shown as zero. It is priced at what the same tokens would cost through the API and labelled as covered by a plan. That is what lets you see what a plan is worth to you.
Every day was worth something; almost no day was billed
Each bar is what a day's work was worth at API prices. The highlighted part was billed to an API key.
Swipe sideways to see the whole chart.
Show the data
| Day | Worth | Billed |
|---|---|---|
| 2026-09-01 | $611.08 | $0.05 |
| 2026-09-02 | $1101.53 | $1.72 |
| 2026-09-03 | $611.60 | $0.82 |
| 2026-09-04 | $17.00 | $5.59 |
| 2026-09-05 | $34.60 | $0.60 |
| 2026-09-06 | $23.79 | $2.29 |
| 2026-09-07 | $244.40 | $0.00 |
| 2026-09-08 | $370.86 | $19.75 |
| 2026-09-09 | $277.92 | $8.16 |
| 2026-09-10 | $2122.45 | $1.43 |
| 2026-09-11 | $0.00 | $0.00 |
| 2026-09-12 | $1281.20 | $0.89 |
| 2026-09-13 | $4.98 | $0.01 |
| 2026-09-14 | $3.02 | $0.00 |
| 2026-09-17 | $29.47 | $29.47 |
| 2026-09-18 | $18.02 | $17.39 |
| 2026-09-19 | $1429.43 | $0.16 |
| 2026-09-20 | $75.34 | $0.81 |
| 2026-09-21 | $213.11 | $123.38 |
| 2026-09-22 | $0.15 | $0.00 |
| 2026-09-23 | $1339.08 | $0.79 |
| 2026-09-25 | $105.56 | $0.17 |
| 2026-09-26 | $516.01 | $0.10 |
| 2026-09-27 | $801.24 | $0.02 |
| 2026-09-28 | $854.50 | $0.06 |
| 2026-09-29 | $1161.75 | $3.00 |
| 2026-09-30 | $1975.79 | $0.00 |
Price the work you don’t pay for. A bill of $216 tells you nothing about how hard your plans are working. The $15,007 next to it does.
How a token becomes a price
Dodaios prices a call with three counts and a rate card. Input is new text the model reads. Cache reads are text the provider kept from the call before and lets the model read again at a discount: a tenth of the input rate for most models, a quarter for Gemini and Grok. Output is what the model writes. Here is the most valuable single hour of the month, one Claude Code session on September 1:
One hour of one coding agent, worth $187
The three parts of the price, with the token counts and rates Dodaios used.
Swipe sideways to see the whole chart.
Show the data
| Part | Tokens | Rate per million | Price |
|---|---|---|---|
| Input | 4,260,943 | $10 | $42.61 |
| Cache reads | 128,306,379 | $1 | $128.31 |
| Output | 324,964 | $50 | $16.25 |
Where the price comes from depends on what the tool tells us. When a tool reports its own price for a call, as Grok Build does, Dodaios keeps that number. Otherwise it applies its rate card. A local model, through Ollama for example, costs nothing. A model Dodaios has no rate for is counted as unpriced, never as free: in September that was 7.8 million tokens across 50 calls, and the Spend section shows them on their own tile so a gap cannot hide inside a small total.
Most of it is the agent re-reading
The receipt above has a pattern that holds for the whole month. A coding agent sends its conversation to the model on every step, so the same text is read again and again. The cache makes each of those reads cheap, but there are a lot of them.
97% of our tokens were re-reads, and they made up 73% of the value
September's tokens, and their value at API prices, split into cache reads, input and output.
Swipe sideways to see the whole chart.
Show the data
| Cache reads | Input | Output | |
|---|---|---|---|
| Tokens | 21,521,588,111 | 658,653,662 | 59,945,932 |
| Value | $11,194 | $2,529 | $1,563 |
Output, the part that feels like “the work”, was a quarter of one percent of the tokens and a tenth of the value. If you want to make an agent cheaper, shorter conversations do more than shorter answers.
Where the value went
Almost all of it went to the coding agents in the Agentic IDE. The parts of Dodaios you talk to are tiny next to them, so the next chart uses a log scale: each step to the right is a hundred times more.
Coding agents were 98% of the value; voice and background work cost dollars
Ring: what each part of the app was worth at API prices. Dot: what was billed to an API key.
Swipe sideways to see the whole chart.
Show the data
| Part of the app | Worth | Billed | Tokens |
|---|---|---|---|
| agentic-ide | $14861.27 | $189.45 | 21,153,743,993 |
| agent-chat | $341.48 | $6.07 | 1,064,265,292 |
| voice | $13.22 | $13.22 | 14,659,904 |
| background | $7.90 | $7.90 | 7,518,516 |
| jarvis-voice | $0.01 | $0.01 | 0 |
A month of talking to Dodaios cost $13.22. Most of that was realtime voice on Gemini Live ($9.70), which hears and speaks in one model; the few calls that used a separate speech recognizer ran it on a local Whisper model for nothing. The background jobs that keep the wiki and memory up to date made 724 calls for $7.90. And 612 million tokens ran on local and free models at no cost at all.
The coding agents split by tool. In the app, the Breakdown panel shows it:
Codex and Claude Code did 96% of the work
Breakdown, grouped by provider, last 30 days. Click a row and the whole section filters to it.
What actually got billed
Switch to Billed to keys and the section shrinks to the money that left an API key. For September that is $216.65, and one row dominates it.
Billed to keys: $217, and 87% of it is one tool
The same section with the billing switch on Billed to keys, last 30 days.
Where the $216.65 went
Everything billed to an API key in September, by what it was for.
Swipe sideways to see the whole chart.
Show the data
| What | Billed |
|---|---|
| Grok Build, coding agent on our own xAI key | $189.45 |
| Voice: realtime, pipeline and tool models | $13.22 |
| Background jobs: wiki, curation, awareness | $7.90 |
| Chats with agents on API keys | $6.07 |
| Speech-to-text and text-to-speech | $0.01 |
Grok Build is the coding agent from xAI, and it runs on our own API key instead of a plan. Dodaios records the price Grok reports for each call, so its row is real money, not an estimate. Most of it came from one evening. Open September 21 in the Daily report and the day tells you exactly that:
September 21: two hours, $123 billed
Daily report → Monday, September 21. Every day of the range opens like this.
Nine Grok calls between 18:08 and 20:12 were billed $122. A Google Antigravity agent read more tokens than Grok that evening, $89.73 worth, and billed nothing, because it runs on a plan.
The expensive agent is the one on a key, not the one doing the most work. The highest value we saw all month was a $2,122 day. The highest bill was a two-hour evening with a tool we pay per token.
What a subscription number does not tell you
The $15,007 covered by plans is not money we spent. It is what the same tokens would have cost through the API. Dodaios cannot know what your plan costs or how close you are to its limits in dollars, so it does not pretend to: it shows the list price of the work and leaves the comparison to you. If a plan costs you a fixed amount per month and Dodaios shows you ten times that in covered work, the plan is paying for itself.
What broke on the way
Counting tokens sounds like adding numbers. It took several rounds to get right, and each one changed the total by a lot.
A $37,000 bill that never existed. On August 24 the Spend section showed one machine a month of roughly $37,000. Two Codex habits caused it. Codex counts cached tokens inside its input number, where Claude Code reports them separately, so the cache was priced twice. And a forked Codex thread replays its whole history into a new file, so every fork looked like hours of fresh work. Dodaios now subtracts the cached share and recognises a replayed call by Codex’s own running total.
Twice the tokens from the same answer. Claude Code writes one model response as several lines, one per content block, and each line repeats the same usage numbers. On a sample transcript that was 64 lines for 31 responses. Dodaios now counts a response by the id the API gave it, not by the line.
A fifth of all Claude Code calls were invisible. When Claude Code starts a subagent, that subagent writes its own transcript in a subfolder. Until August 27 nothing read those files. On the machine we measured, they held 14,466 of 68,937 responses.
The past shrank every night. Claude Code deletes old sessions after 25 days on that machine, and when a transcript disappeared, its cost disappeared with it. The lifetime total got a little smaller every night. Dodaios now keeps what it has read as a ledger, so deleting a transcript no longer deletes the money it cost.
A rebuild showed $8,000 of a $13,600 month. An early version threw its index away and re-read everything when a counting rule changed, and showed the half-built number in the meantime. Now it corrects rows in place, and while it is still reading it says so. That is the dashed notice in figure 1.
A voice key paid for the wiki. On September 29, an OpenAI key added for voice paid about $0.30 of background wiki calls after a two-minute chat. Small, but nobody had asked for it. Since then, background work only runs on subscriptions or local models while a subscription is connected, and waits rather than falling back to a key.
Make a gap visible, never zero. Every one of these bugs made a number quietly wrong rather than loudly missing. The section now shows unpriced tokens on their own tile and says when it is still counting, because a confident wrong total is worse than an honest incomplete one.
If you run Dodaios yourself
- Open Settings → Activity → Spend. Leave it on 30 days, switch to Billed to keys once to see what you actually pay, then to On subscriptions to see what your plans cover.
- Check the Unpriced tile. If it is not zero, some model has no rate yet, and its work is missing from every dollar figure.
- Open your most expensive day in the Daily report. It usually names one tool and one evening.
- Look for keys in the coding agents. A coding agent on a pay-per-token key costs far more than voice and background work together.
- A chat shows its own receipt. Under each agent turn that reported a cost, the chat shows its tokens and price.
If a number in your Spend section looks wrong, open an issue on GitHub with the day it happened.
How we measured. All numbers come from the Spend section’s own data on the Windows machine Dodaios is built on, for the calendar month of September 2026 in Central European time, read on October 1. The screenshots show the app’s 30-day range on that day, which starts on the afternoon of September 1 and runs into October 1, so their totals are slightly larger than the text’s. The split into cache reads, input and output in figure 4 applies the Dodaios rate card model by model and lands within half a percent of the app’s total. Subscription figures are list prices of the same tokens through the API, not money paid. Work done in the minutes before we read the numbers may still have been on its way into the index. Chats with agents that run through Claude Code or Codex may also appear in those tools’ own transcripts; we have not ruled out that such a turn is counted twice, which would put at most $341 of the value, about 2 percent, too high and none of the bill.