AI Receipts
Explainer

· 6 min read · By The AI Receipts team

What is cost per task? Why the cheapest AI model per token isn't the cheapest per job

Per-token prices tell you the rate, not the bill. Cost per task counts every token a model burns to finish a job. Here is how it works, with real numbers from GPT-6, Claude and Gemini.

Claude Opus 5.5 costs $4 per million input tokens and $20 per million output tokens (Anthropic). GPT-6 Astra costs $10 and $50 (OpenAI). On the price list, Astra is 2.5 times more expensive.

Now run both models on the same set of real work. Artificial Analysis did, and reports that Opus 5.5 costs $5.98 per task while Astra costs $3.26 (Artificial Analysis: Opus 5.5; Artificial Analysis comparisons). The “expensive” model does the job for about 45% less.

That gap is what cost per task measures. Here is what it is, why per-token prices mislead, and how to use it without getting fooled in the other direction.

Cost per task, in one sentence

Cost per task is what you actually pay, in dollars, for a model to finish one unit of work: every input token it reads, every cached token it re-reads, every reasoning token it “thinks” with, and every answer token it writes, each multiplied by its price.

A per-token price is a rate. Cost per task is the bill. It’s the difference between a taxi’s price per mile and what you pay after the driver takes the scenic route.

Why per-token prices mislead

A token is a chunk of text: a short word, or a piece of a longer one. You pay for tokens in, and tokens out. The trap is assuming two models use the same number of tokens to do the same job. They don’t, and the spread is huge.

On the Artificial Analysis Intelligence Index, the average output tokens per task are (Artificial Analysis comparisons):

Model Output tokens per task Of which reasoning
Claude Opus 5.5 (max) 119k 84k
Gemini 4 Argon (high) 62k 36k
GPT-6 Astra (max) 27k 17k

Opus writes about 4.4 times as many output tokens per task as Astra (119k ÷ 27k). A price that’s 2.5 times lower can’t cover a token count that’s 4.4 times higher. That’s the whole trick.

Most of that extra volume is reasoning tokens: the model’s working-out before it answers. You don’t see them in the reply, but you pay for them. Google’s pricing page says it plainly: Gemini 4 Argon’s output price is “including thinking tokens” (Google).

There’s also a quieter multiplier: tokenizers. Anthropic notes that Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text” (Anthropic). Same words, more tokens, bigger bill. Per-token prices across vendors aren’t even counting the same unit.

How cost per task is calculated

Artificial Analysis introduced cost per task with version 4.1 of its index. It takes the total cost for a model to run the whole Intelligence Index and divides by the number of tasks (Artificial Analysis). Each evaluation’s cost is built from “input, cache hit, cache write, reasoning, and answer token prices”, divided by task count and weighted by that evaluation’s weight in the index (Artificial Analysis). The current index, v4.3.2, has 10 evaluations, mostly agentic and professional work such as Terminal-Bench 4.0, GDPval-AA and AA-LCR (Artificial Analysis).

You can do the same thing for your own workload. The formula is just a receipt:

cost per task =
    (input tokens        × input price)
  + (cached input tokens × cache-hit price)
  + (cache-write tokens  × cache-write price)
  + (output tokens       × output price)    ← reasoning + answer
  ÷ 1,000,000

Anthropic’s own docs show a worked example: a coding session on Opus 5.5 with 50,000 input tokens and 15,000 output tokens costs $0.20 + $0.30 in tokens (Anthropic). Note which line is bigger: there are 3.3 times as many input tokens, but output still costs more, because it’s priced 5 times higher.

The receipt: four models, one benchmark

Here are the numbers side by side. Prices are standard API list prices per million tokens; cost per task is Artificial Analysis’s measured figure.

Model Price in / out Index score Cost per task
Claude Opus 5.5 (max) $4 / $20 58 $5.98
GPT-6 Astra (max) $10 / $50 53 $3.26
Gemini 4 Argon (high) $2 / $10 (intro) 53 $1.99
GPT-6.1 Sol (max) $2 / $10 52 $0.72

Sources: Opus 5.5, GPT-6.1 Sol, Argon and Astra, list prices from Anthropic, OpenAI and Google. Our price tracker keeps the list prices current.

Three things jump out:

  1. Same sticker, different bill. Argon and GPT-6.1 Sol have identical list prices, $2 / $10. Sol does an index task for $0.72; Argon needs $1.99, about 2.8 times more.
  2. “Expensive” can be cheaper. Astra has the highest per-token prices in the table, yet it does a task for about 45% less than Opus 5.5.
  3. The best model is also the dearest per job. Opus 5.5 leads on score (58), but each task costs about 8.3 times what Sol charges ($5.98 vs $0.72) for 6 more index points. Whether that’s worth it depends on what a wrong answer costs you.

And one caveat on Argon: its $2 / $10 is an introductory price through Nov 30, 2026, rising to $4 / $20 on Dec 1 (Google). Artificial Analysis puts its cost per task at $3.98 at standard pricing (Artificial Analysis). We covered that coupon in issue #001.

Input is often the bigger half

It’s tempting to think “output is where the money goes.” Check the arithmetic. Using the output-tokens-per-task figures above and each model’s list output price:

Model Output only (tokens × price) Measured cost per task Everything else
Opus 5.5 119k × $20/M = $2.38 $5.98 $3.60
Astra 27k × $50/M = $1.35 $3.26 $1.91
Argon 62k × $10/M = $0.62 $1.99 $1.37

For all three, output is less than half the bill. The rest is input: on agentic tasks a model re-reads its context, tool results and files on every step. That’s why caching matters. Anthropic charges 5% of the base input price for cache hits on Opus 5.5 ($0.20 per million) (Anthropic), and Google charges $0.10 per million for Argon’s cached input during the promotion (Google). Your cache hit rate can move your real cost more than the headline price.

(Rounding note: these are averages, and the token counts are rounded to the nearest thousand, so treat the last column as approximate.)

Where cost per task can fool you too

Cost per task is a better number. It isn’t a magic one.

  • “Task” means their task. The index is weighted towards agentic and professional work. If your job is short classification or one-line summaries, token counts will look nothing like this. Measure your own.
  • Settings change everything. “(max)” and “(high)” are reasoning-effort settings. The same model on a lower setting burns fewer tokens and scores lower. Always compare like with like.
  • Cheap per task isn’t cheap per correct task. If a model is half the price but you need to run it twice, or a human has to fix its work, the saving is gone. Pair cost per task with an accuracy number from the same benchmark.
  • Discounts and tiers move it. Batch processing is 50% off at both Anthropic and OpenAI (Anthropic; OpenAI). OpenAI’s Fast tier doubles Astra to $20 / $100 (OpenAI). A cost-per-task figure is only valid for the tier it was measured on.

How to use it: a five-minute checklist

  1. Start from list prices for input, cached input and output. Our AI model price tracker has them with sources and check dates.
  2. Find independent token counts. Artificial Analysis publishes output tokens and cost per task for each model; vendor launch posts rarely do.
  3. Run 20–50 of your own real requests and log input, cached and output tokens from the API’s usage fields.
  4. Multiply it out with the formula above, and divide by the share of tasks that came out right.
  5. Re-check when prices change. Introductory prices end. We log price changes on the tracker.

That’s the same approach we use for every claim on this site: pin down the claim, find the primary source, show the math. It’s written up on our methodology page, and you can see it applied in our receipts.

The bottom line: a per-token price is the menu. Cost per task is the receipt. Read the receipt.