Model Intelligence, Token Use, and Cost per Task
Comparison snapshot: 2026-07-26. Prices and benchmark values change quickly; the linked primary sources are the authority for current values.
Executive summary
There is no single fair number called “cost per intelligence.” A model can have a low price per token but use many more tokens, or score well on a general benchmark while being a poor coding agent. The useful comparison is therefore three-dimensional:
- Capability: a benchmark score, with the benchmark and reasoning setting named explicitly.
- Token use: measured tokens for the same evaluation or task suite.
- Task cost: the input/output token mix multiplied by the applicable prices.
On the common Artificial Analysis Intelligence Index, Claude Opus 4.8 has the highest score in this set, followed by GPT-5.6 Terra, Claude Sonnet 5, and GPT-5.6 Luna. However, the same source reports that Sonnet 5 generated far more tokens than the other models in its evaluation. Cursor Composer 2.5 is a separate case: it scores 62 on the Coding Agent Index and has very low measured coding-agent task costs, but it is not reported on the same Intelligence Index.
At-a-glance comparison
| Model | Access | Context | Input / output price per 1M tokens | Common benchmark score | Measured benchmark tokens |
|---|---|---|---|---|---|
| Cursor Composer 2.5 | Cursor IDE and Cursor CLI only | Not disclosed in the cited sources | Standard: $0.50 / \(2.50**; Fast: **\)3 / $15 | 62, Coding Agent Index | Not published in the cited sources |
| GPT-5.6 Luna (max) | OpenAI API | 1.05M | $1 / $6 | 51, Intelligence Index | 130M generated tokens |
| GPT-5.6 Terra (max) | OpenAI API | 1.05M | $2.50 / $15 | 55, Intelligence Index | 96M generated tokens |
| Claude Sonnet 5 (adaptive reasoning, max effort) | Anthropic API and cloud platforms | 1M | $2 / \(10** introductory; **\)3 / $15 standard | 53, Intelligence Index | 300M generated tokens |
| Claude Opus 4.8 (adaptive reasoning, max effort) | Anthropic API and cloud platforms | 1M | $5 / $25 | 56, Intelligence Index | 120M generated tokens |
The OpenAI and Anthropic figures above are not ordinary single-task measurements. They are the total generated tokens used by Artificial Analysis while evaluating each model across its Intelligence Index suite. They are useful for comparing evaluation efficiency, but they cannot be converted to tokens-per-task without the suite's task count and exact accounting rules.
Sources: Cursor Composer 2.5 pricing, Cursor model pricing, GPT-5.6 Terra, GPT-5.6 Luna, Claude model overview, and Claude pricing.
Intelligence Index results
Artificial Analysis reports the following Artificial Analysis Intelligence Index results for the max-effort or adaptive-reasoning configurations:
| Model | Intelligence Index | Generated tokens for the evaluation | Evaluation cost | Evaluation dollars per index point |
|---|---|---|---|---|
| GPT-5.6 Luna | 51 | 130M | $954.37 | $18.71 |
| GPT-5.6 Terra | 55 | 96M | $2,009.92 | $36.54 |
| Claude Sonnet 5 | 53 | 300M | $4,010.12 | $75.66 |
| Claude Opus 4.8 | 56 | 120M | $3,752.55 | $67.01 |
The last column is calculated as:
evaluation dollars per index point
= Artificial Analysis evaluation cost / Intelligence Index score
This is not the price of one user task and should not be presented as one. It is a diagnostic for how much the published evaluation run cost for each point of the final index score. It includes the suite's task mix, prompting, tool use, retries, and the model's selected reasoning behavior.
The source pages are GPT-5.6 Luna, GPT-5.6 Terra, Claude Sonnet 5, and Claude Opus 4.8.
What the token totals suggest
- Luna is the cheapest model in this group and scored 51, but it generated 130M tokens, so its low unit price partly compensates for high verbosity.
- Terra generated fewer tokens than Luna and Sonnet 5, while scoring higher than both. Its output price makes the complete evaluation more expensive.
- Sonnet 5 scored 53 but generated 300M tokens, the highest total in this comparison. Token efficiency is therefore an important part of its practical cost.
- Opus 4.8 scored 56 with 120M generated tokens. It is the most capable of these four on this index, but its per-token price remains high.
These conclusions apply only to the cited evaluation configuration. Changing reasoning effort, tools, context, or stopping criteria can change both score and token use.
Cursor Composer 2.5 is a separate coding-agent comparison
Composer 2.5 should not be assigned an Artificial Analysis Intelligence Index score by inference. Cursor publishes it through the Cursor product rather than as a general-purpose API model, and Artificial Analysis evaluates it on a different Coding Agent Index.
Artificial Analysis reports:
| Variant | Coding Agent Index | Measured cost per coding-agent task | Average wall time |
|---|---|---|---|
| Composer 2.5 Standard | 62 | $0.07 | 9.3 minutes |
| Composer 2.5 Fast | 62 | $0.44 | 6.7 minutes |
The Fast variant is about 30% faster in that evaluation and costs about six times as much. Cursor lists the underlying token rates as \(0.50/\)2.50 per million input/output tokens for Standard and \(3/\)15 for Fast. Composer 2.5 is available in Cursor IDE and Cursor CLI; the cited sources do not provide a general public API or a directly comparable Intelligence Index result.
Sources: Cursor's Composer 2.5 release note and Artificial Analysis' Coding Agent Index report.
A reproducible reference task
Because public sources do not expose a common token-per-task trace for all five models, a transparent comparison can use a declared reference workload:
reference task = 20,000 input tokens + 5,000 output tokens
no prompt-cache discount
no tool-call fees
no retries
For a model with input price p_in and output price p_out, the task cost is:
task cost = 20,000 / 1,000,000 * p_in
+ 5,000 / 1,000,000 * p_out
| Model / price state | Cost for the reference task |
|---|---|
| Cursor Composer 2.5 Standard | $0.0225 |
| GPT-5.6 Luna | $0.0500 |
| Claude Sonnet 5 introductory | $0.0900 |
| GPT-5.6 Terra | $0.1250 |
| Cursor Composer 2.5 Fast | $0.1350 |
| Claude Sonnet 5 standard | $0.1350 |
| Claude Opus 4.8 | $0.2250 |
These are arithmetic estimates, not observed costs for completed engineering tasks. They answer “what would this token mix cost?” They do not answer “how many tokens will the model need to finish my task?” For the latter, the evaluation's measured task traces are required.
Recommended cost-per-correct-task metric
For a real coding-agent study, record every model request and aggregate by task:
task_cost =
uncached_input_tokens * input_rate
+ cached_input_tokens * cached_input_rate
+ output_tokens * output_rate
+ tool_call_fees
+ retry_costs
cost_per_correct_task =
median(task_cost for successful tasks)
/ first_try_success_rate
Use the median for skewed agent workloads, report the mean separately, and publish the task suite, model version, reasoning setting, tool permissions, retry policy, and cache policy. A model that is cheaper per request but needs two retries is not necessarily cheaper per correct result.
For a coding-agent comparison, pair that cost metric with a task-quality score such as pass rate, patch correctness, regression rate, and human review quality. Do not combine an Intelligence Index score and a Coding Agent Index score into a single ranking unless the benchmark owners provide a validated calibration.
Bottom line
- Choose Claude Opus 4.8 when the highest score on this Intelligence Index matters more than raw API cost.
- Choose GPT-5.6 Terra for a stronger balance of score and evaluation token use than Luna, while accepting the higher output rate.
- Choose GPT-5.6 Luna for cost-sensitive high-volume work where a score of 51 is sufficient.
- Treat Claude Sonnet 5 as a capable workhorse, but measure verbosity: the cited evaluation generated substantially more tokens than the other models.
- Choose Composer 2.5 when the workload is specifically Cursor-based agentic coding and the Coding Agent Index/task-cost tradeoff is more relevant than a general intelligence ranking.
The strongest production decision is usually empirical: run a representative private task set, log token counts and retries, and compare dollars per correct task rather than relying on list prices or one headline benchmark.