Opus costs 30 times more than Haiku to answer my training questions. It wasn't better.
I asked three Claude models the same 20 questions about my Garmin data, three times each, and itemised every bill. Haiku answered for under a cent on average, Opus for 11 to 23 cents, and all three got the facts right.
- Own training data
- Code & method included
- AI-assisted, author-checked

One question, one receipt, three very different totals. (AI-generated illustration)
I run, and I write software. Garmin MCP is my unofficial, open-source MCP server that lets an AI assistant answer questions about my Garmin Connect data. I wrote earlier about what the tool list costs and about how much smaller the server's answers are than Garmin's raw JSON. Both were parts of the bill. I had never measured the whole bill for a normal question, from the first request to the last token of the answer. So I did.
A note before the numbers. If you use Claude through a subscription, in the Claude app or in Claude Code signed in with it, you pay a flat monthly fee and have usage limits, not a per-token bill. Everything below is at API list prices, the price of the same tokens when you pay per token with an API key. For a subscriber the numbers show what the questions use up, not what they cost.
The experiment¶
I wrote 20 questions the way I ask them, 9 in Polish and 11 in English, at three levels:
- Simple, one lookup: "How did I sleep on the night of 17 to 18 November?", "How many steps did I take on 16 November?", "Show my last 5 activities."
- Medium, one or two tools and a summary: "Review my training week of 9 to 15 November", "Summarise my October", "Compare my runs on 3 and 4 November."
- Complex, several tools, a comparison or a plan: "Compare my last four weeks with the four before and plan my next week", "Have I recovered from my half marathon? Look at HRV, resting heart rate, sleep and load", and a 6×400 m interval session built from my threshold pace, shown but not saved.
Each question went through claude -p in Claude Code 2.1.330 with the real server and nothing else: no built-in tools, no settings, no other MCP servers. The server ran on a frozen copy of my local database with downloads off and no sign-in, so every run saw the same data and nothing reached Garmin. The copy ends on 18 November, which is why most questions carry a date.
Three models answered every question three times: Claude Haiku 5.5, Claude Sonnet 5.5 and Claude Opus 5.5. That is 180 answers. For every API request I kept the token counts split the way they are billed: uncached input, cache writes, cache reads and output. Prices are the list prices on Anthropic's pricing page on 21 November 2026.
Before any model answered, I wrote a rubric for each question: 76 items in total, each a fact from my data that a good answer must state correctly ("sleep 6 h 35 min, score 69") or a behaviour it must show ("saves nothing"). Claude Sonnet 5.5 then graded every answer against the rubric and the server's own results for that question, without knowing which model wrote it. I checked the grader too; more on that below.
What every question starts with¶
Before the model sees the question, the client sends its own system prompt and the full tool list. For this setup that is about 18,000 tokens on every first request, whatever you ask.

The fixed part of each question, measured per model with "Reply with OK."
My first estimate for the 21 tools was about 9,700 tokens: the rule of thumb of four bytes per token applied to 38,761 bytes of JSON. Measured here, all 21 tools with the server's instructions take 17,595 tokens with Sonnet 5.5, about 2.2 bytes per token. JSON is denser in tokens than prose, which I found for tool results too, and the client adds its own wrapping around each tool. The 16 tools of this test, with the write tools removed, took 14,821.
The question itself is a few dozen tokens at most. Next to the fixed part it is a rounding error.
The receipt¶
Here is what three real Sonnet answers cost, line by line.

Three receipts from Sonnet 5.5. A token counts again every time a later request re-reads it.
A typical answer took two API requests. In the first, the model reads the question and asks for tools, often several at once. In the second, it reads the tool results and writes the answer. Each request carries everything before it, so the fixed part is paid twice.
Across all 60 answers per model, the same picture holds:

Where the tokens and the money go, averages over 60 answers per model.
The fixed part is 84 to 89% of the prompt tokens billed for a question, but only about a third of the cost. Those tokens are mostly cache reads, which cost a twentieth of the input price on Sonnet and Opus and a tenth on Haiku. The tool results, my actual data, are only 10 to 15% of the tokens and another third of the cost, because they are new in each conversation and get written into the cache first. The answer is the last third.
Two smaller lines surprised me. Claude Code sends a short request of its own to Haiku 5.5 with every question, about 1,200 tokens, for 0.015 cents. And Haiku thinks more than the larger models: of its 2,301 output tokens per answer, 1,362 were thinking, against 123 for Sonnet and 431 for Opus.
The cache decides the bill¶
Prompt caching is what makes the fixed part cheap, and it has a catch. In my runs Claude Code wrote every cache entry with a one-hour lifetime, which costs twice the normal input price to write. Reading it back is cheap, but only within the hour.
My test ran questions back to back, so almost every answer found the system prompt and tool list already cached. A real day looks different: a question in the morning, another after lunch. For each answer I also computed what it would have cost with an empty cache, the first question after a break.
Average cost per question, cache warm against cache cold:
- Haiku 5.5: 0.39¢ against 0.67¢ (simple questions 0.20¢ / 0.47¢, complex 0.73¢ / 1.0¢)
- Sonnet 5.5: 4.6¢ against 10.4¢ (simple 2.7¢ / 8.5¢, complex 7.2¢ / 13.0¢)
- Opus 5.5: 11.4¢ against 23.1¢ (simple 5.8¢ / 17.5¢, complex 19.0¢ / 30.6¢)
For a simple question on Sonnet, the cold cache triples the price. Writing 18,000 tokens of fixed part at the one-hour rate costs 7.2 cents, more than the whole rest of the answer. Priced with no caching at all, the average Sonnet question would cost 10.1 cents, almost exactly the cold figure. A lone question gains nothing from the cache; the savings start with the second request inside the hour.
This also changes how to ask several questions. I asked five of them in one conversation and, separately, as five new conversations, twice per model.

Five questions in one chat against five separate chats, two runs each.
One conversation was the cheapest in every case, even though each later question re-reads the earlier ones: the prompt of Sonnet's fifth question started at 30,655 tokens instead of 18,071. Those are cache reads. The expensive case is the one people do without thinking: a new chat for every question, an hour apart. Five such Sonnet questions cost 52 cents; the same five in one conversation started after a break, about 25. With two runs per condition, read the gaps as a direction, not a precise saving.
What the money buys¶
The cost spread is large. Per question, Sonnet cost about 12 times as much as Haiku and Opus about 2.5 times as much as Sonnet. The answers were not different in a way the rubric could see.

Quality against cost per question. Filled points: cache warm, as measured; open points: cache cold.
Haiku got 98.1% of the rubric items right, Sonnet 99.2% and Opus 98.3%. Their intervals overlap, and on simple questions all three were perfect. The misses were few and ordinary. Haiku built the 6×400 m session at threshold pace instead of a little faster, in all three runs, and once said its easy runs had not changed when its own numbers showed them slower at the same heart rate. Opus twice reviewed my week with ranges of HRV and resting heart rate instead of the averages. Sonnet skipped weekly training stress when asked how my load built up before the half marathon. (HRV, resting heart rate and readiness here are training information, not medical advice.)
The test has a ceiling: questions about my own data, answered by tools that already do the arithmetic. Harder coaching questions might separate the models; these did not.
Checking the grader¶
A model grading other models needs checking. I did it two ways.
First, a random sample of 18 answers, six per model, two per level. I graded all 81 rubric items myself before looking at the grader's verdicts. The grader's first pass agreed on every one, and its second pass on 80 of 81. In those 18 answers I also found three wrong statements of fact, one per model: four runs and 50.6 km described as "five runs, about 50 km plus the race", a ride put into the wrong week, and 8 h 58 min of sleep called "almost 9 hours in bed".
Second, every item the grader marked wrong or missing in its first pass: 30 of 684. I agreed with 12. Ten of the 18 I overturned had the same cause: the model chose a window up to 21 November, stated it, and got numbers that differ from my reference window ending on the 18th. Nine of them answered "the last four weeks". The grader called those wrong despite an instruction to accept a stated window. The scores above use my decision on those 30 items.
The grader was reliable where answers were right and over-strict where they differed from my reference, so I report the rubric score, not its noisier count of errors.
Speed¶

Time to the complete answer by level, median and every answer.
A simple question took 6 to 9 seconds with any model. On complex ones, Haiku was the slowest of the three, with a median of 31.5 seconds against 18.9 for Sonnet. It made about as many tool calls but thought much longer: 3,833 thinking tokens per complex answer, against 359 for Sonnet and 1,057 for Opus. The cheapest model was not the fastest when the question got hard.
A month of questions¶
Say you ask three questions a day, in the mix of this test, every day for a month.

Ninety questions a month at API list prices.
If every question comes after a break, Haiku costs 60 cents a month, Sonnet $9.33 and Opus $20.75. If you ask them close together, about half that. On an API key that is the bill. On a subscription it is part of your usage limit instead.
What this does not show¶
- One athlete, my questions. 20 questions on my own data, written by someone who knows the tools; a rubric I wrote, with a ceiling all three models reached.
- One client. Claude Code 2.1.330 with its own system prompt and its one-hour cache. Another client has a different fixed part and may cache differently. With a five-minute cache, the cold Sonnet question would cost 7.0 cents instead of 10.4.
- List prices, not an invoice. Costs are computed from the billed token counts. In this version of Claude Code the reported
total_cost_usdmatched my calculation in all 180 runs, side request included; in the older version I used before, it did not. - Few repetitions. Three runs per question, two per condition in the conversation test.
- A warm cache in the test. The cold numbers are computed from the measured tokens, not measured after real breaks.
If you are building an MCP server¶
- Measure the fixed part with your client's tokenizer, not bytes divided by four. Mine was almost double my estimate.
- The tool list is paid on every question, written to the cache at a premium when the cache is cold. A shorter list saves most where questions are rare.
- Keep tool results small. They were a third of the cost even after the server cut them down.
- Try the small model. On questions about the user's own data, answered by tools that do the maths, Haiku matched the big ones at a twelfth of Sonnet's price.
The scripts, the questions, the rubric and the per-answer metrics sit beside this article, without the answers, which hold my data. The server is at https://github.com/endurancetools/garmin-mcp, and the documentation is at https://endurancetools.github.io/garmin-mcp/.
Unofficial; not affiliated with or endorsed by Garmin.
Some illustrations in this article were generated with ChatGPT.