All Posts
AI Engineering July 11, 2026

Grok 4.5 vs Sonnet 5: Production Cost, the Sonnet Tokenizer, and Throughput at Volume (July 2026)

On the price sheet Grok 4.5 and Sonnet 5 look close, roughly a couple of dollars in and single digits out per million tokens. In production they are not close, because Sonnet 5 ships a new tokenizer that maps the same English text to about 40 percent more tokens, and you pay per token, not per word. Add throughput and the effective cost gap widens further. We work through the real per word economics and where each model still earns its place in a high volume system.

Grok 4.5 vs Sonnet 5: Production Cost, the Sonnet Tokenizer, and Throughput at Volume (July 2026)

If you are picking a workhorse model for a system that runs at volume, Grok 4.5 and Claude Sonnet 5 look like a close call on the price sheet. They are not close once you account for the two things the price sheet hides: how many tokens each model charges you for the same text, and how fast it serves. Sonnet 5 shipped a new tokenizer that maps the same English input to roughly 40 percent more tokens, and you pay per token, so its effective rate is meaningfully higher than its list rate. Here are the numbers that actually set your bill.

Metric Grok 4.5 Sonnet 5
Input, list per 1M tokens $2.00 $2.00 intro, then $3.00
Output, list per 1M tokens $6.00 $10.00 intro, then $15.00
English tokens per unit of text baseline ~1.4x baseline
Effective input, per 1M tokens of English $2.00 ~$2.84
Effective output, per 1M tokens of English $6.00 ~$14.20
Observed serving speed ~80 tok/sec slower in head to head runs

The introductory Sonnet 5 rate of $2 input and $10 output runs through August 31, after which it reverts to $3 and $15. But the more important row is the tokenizer. Because Sonnet 5 emits about 1.4 times as many tokens for the same English passage, its effective cost per unit of real content is closer to $2.84 input and $14.20 output even at the introductory rate. The list price comparison flatters Sonnet 5. The per word comparison does not.

The Tokenizer Is a Hidden Price Increase

Almost every model comparison quotes price per million tokens as though a token were a fixed unit of work. It is not. A token is a chunk of text whose size depends on the model's tokenizer, and different tokenizers slice the same sentence into different numbers of pieces. Sonnet 5 introduced a tokenizer that, for English, produces roughly 40 percent more tokens than the baseline many teams are used to, with smaller inflation for Spanish, around 1.33 times, and roughly flat behavior for Simplified Mandarin.

That matters because you are billed per token, not per word or per character. If Sonnet 5 turns a 1,000 word document into 40 percent more tokens than Grok 4.5 does, then even at an identical list price per token, Sonnet 5 costs 40 percent more to process that document. The introductory list rates make the two look comparable on input and only moderately apart on output. Adjust for the token multiplier and the real gap on English content is large: roughly $2.84 versus $2.00 on input and $14.20 versus $6.00 on output. For an English heavy workload at volume, that is not a rounding error, it is the difference between two very different monthly invoices.

The practical implication is that you cannot compare two models on price without normalizing for their tokenizers. The honest unit is cost per thousand words of your actual content, in your actual languages, not cost per million tokens. If your traffic is heavily Mandarin, the Sonnet 5 penalty largely disappears and the list prices are close to the real story. If it is English or Spanish, apply the multiplier before you decide.

Normalizing Cost Per Thousand Words

Here is a small calculation that converts list prices into the number you actually care about, cost per thousand words, using an estimate of tokens per word for each tokenizer.

def cost_per_1k_words(in_price, out_price, tokens_per_word, in_words, out_words):
    in_tok = in_words * tokens_per_word
    out_tok = out_words * tokens_per_word
    cost = (in_tok * in_price + out_tok * out_price) / 1_000_000
    return round(cost, 5)

# ~1.33 tokens/word baseline for Grok, ~1.4x that for Sonnet 5 English
grok   = cost_per_1k_words(2.00,  6.00, 1.33, 800, 200)
sonnet = cost_per_1k_words(2.00, 10.00, 1.33 * 1.4, 800, 200)
print("Grok 4.5:", grok, "Sonnet 5 (intro):", sonnet)

Feed in your own word counts and language mix rather than the illustrative figures. The function makes the mechanism visible: the tokenizer multiplier compounds with the output price gap, so an output heavy English workload sees the widest divergence, and a short output, Mandarin heavy workload sees almost none. This is the same normalization discipline we applied to caching economics in the prompt caching and cost comparison, where the headline rate again failed to predict the bill.

Throughput Is Part of the Cost

Price per token is only half of the operating cost of a high volume system. The other half is speed, because a slower model holds each connection open longer, which raises the concurrency you must provision to serve the same request rate and worsens latency for interactive users. Grok 4.5 serves at roughly 80 tokens per second and finished a real coding task in about 60 seconds against Sonnet 5's 70 in one head to head run, running on the order of 40 to 60 percent faster on output generation.

Faster serving lowers cost in two ways that never show up on the price sheet. It reduces the number of concurrent workers, and therefore the infrastructure, needed to hit a given throughput, and it shortens the tail latency that drives user drop off in interactive products. That said, speed does not settle the decision alone. A model that is faster per token but needs more retries or produces weaker output on your task can be more expensive and slower end to end, which is why we always come back to cost and quality per completed task rather than tokens per second in isolation. We made that argument concretely for coding in the Sonnet 5 versus Opus 4.8 cost per issue analysis.

Where Each Model Still Wins

Grok 4.5 is the stronger default for cost sensitive, high volume, English or Spanish heavy production workloads. Its lower effective per word cost, once the Sonnet tokenizer is accounted for, plus its faster serving, make it cheaper to run at scale on exactly the traffic most consumer and internal tools generate. For a large fleet of agents or a high request rate API, those two advantages compound month over month. We saw the same production cost logic favor Grok in the Grok versus Qwen production agents comparison.

Sonnet 5 still earns its place where its capabilities, ecosystem, and integration matter more than raw per word cost, on Mandarin heavy workloads where the tokenizer penalty vanishes, on tasks where its quality advantage reduces retries enough to offset the token inflation, and inside teams already standardized on Anthropic tooling and safety posture. The tokenizer change is a real cost, but it is not disqualifying if the model closes your tasks in fewer attempts or fits an existing stack cleanly.

When This Applies to Your Stack

Before you standardize a workhorse model, normalize. Take a representative sample of your real traffic, count the words and the language mix, apply each model's tokenizer multiplier, and compute cost per thousand words rather than trusting the price per million tokens on the vendor page. Then layer in serving speed and your measured task success rate. The model that wins the price sheet and the model that wins your bill are frequently different.

If your team wants that normalization, capacity model, and serving cost analysis built against your own traffic and languages, Contra Collective designs and implements AI integration and agent engineering that holds margin at production scale. Tokenizers and price sheets will keep changing; the habit of pricing your own words, not a vendor's tokens, is what keeps the invoice predictable.

FAQ

Is Grok 4.5 cheaper than Sonnet 5? For English or Spanish heavy workloads, meaningfully yes. Their list input prices are close at the Sonnet 5 introductory rate, but Sonnet 5's tokenizer produces roughly 40 percent more tokens for the same English text, pushing its effective cost to around $2.84 input and $14.20 output per million tokens of content against Grok's $2 and $6. For Mandarin heavy workloads the gap mostly disappears.

What is the Sonnet 5 tokenizer issue? Sonnet 5 ships a new tokenizer that slices the same text into more tokens than many teams are used to, roughly 1.4 times as many for English and 1.33 times for Spanish, while Simplified Mandarin is close to flat. Because billing is per token, more tokens per word means a higher effective price even when the list price per token is unchanged.

When does the Sonnet 5 introductory pricing end? The $2 input and $10 output introductory rate runs through August 31, 2026, after which it reverts to $3 input and $15 output per million tokens. Factor the reversion into any long term cost model, because it widens the gap with Grok 4.5 further once it takes effect.

Is Grok 4.5 faster than Sonnet 5? In the head to head runs cited here, yes. Grok 4.5 serves at roughly 80 tokens per second and finished a coding task in about 60 seconds against Sonnet 5's 70, running on the order of 40 to 60 percent faster on output generation. Faster serving lowers the concurrency you must provision and improves interactive latency.

Should throughput or cost decide my choice? Neither alone. Normalize cost to your own words and languages, then weigh serving speed and your measured task success rate, and choose on cost and quality per completed task. A faster, cheaper model that needs more retries on your workload can lose to a pricier one that closes tasks in a single pass.

[ 02 ] — Keep Reading

More from the lab.

Oct 4, 2026 AI Engineering

The Model Context Protocol's STDIO Problem: Inside the Latest Remote Code Execution Disclosure

Security researchers at OX Security found that the Model Context Protocol's STDIO transport interface runs any process command passed to it on the host system before it ever confirms the subprocess is a valid MCP server, an execute first, validate never pattern that completes an injected command even when the caller eventually gets an error message back. The scope is not small: 150 million downloads across package registries, more than 7,000 publicly accessible MCP servers, and up to 200,000 vulnerable instances across every officially supported SDK, Python, TypeScript, Java, and Rust. Anthropic's response, after OX disclosed in January 2026, was to update documentation and call the behavior intentional. Here is what that actually means if your team runs MCP servers over STDIO.

Sep 30, 2026 AI Engineering

OpenAI's Decisions API: Real-Time Agentic Decision-Making for Enterprise Workflows, Explained

Buried inside OpenAI's DevDay 2026 announcement list alongside GPT-6.1 Sol and Dots agents was a smaller, more technically specific release: a Decisions API built for real time decision making against predefined answer sets. Where the Agents API and a general purpose agent loop are built for open ended reasoning across an unbounded task, the Decisions API is built for the opposite case, a small number of valid outcomes and a requirement that the choice happen fast. This post works through what that distinction actually means in practice and where a bounded decision primitive fits into an existing agentic workflow.

Aug 8, 2026 AI Engineering

Offline Batch Inference on an M5 Max: Maximizing Overnight Throughput for a Prompt Backlog (2026)

Most writing about local inference assumes a human is on the other end, watching tokens appear and judging the model by how fast the first one lands. Batch work is the opposite situation, and it is more common than the interactive framing suggests: you have a backlog of tens or hundreds of thousands of prompts, nobody is waiting on any single one, and the only thing that matters is how much of the pile you can clear before morning. Product descriptions for a catalog, classification over a support archive, embeddings and summaries for a corpus, synthetic data for a fine tune. In that regime latency is irrelevant and throughput is everything, and the settings that make a local server feel responsive to a person actively work against you, because they optimize for the wrong number. Running one prompt at a time on an M5 Max leaves most of the machine idle, since a single decode stream cannot saturate the memory bandwidth the chip has to offer. The job is to keep many sequences in flight so the expensive weight reads are amortized across all of them, and to arrange the backlog so the GPU never waits on padding, scheduling, or a slow tail. This post is about doing that deliberately: what actually bounds batch throughput on Apple Silicon, how far batching takes you before memory stops you, and the operational scaffolding that turns a fragile overnight run into one you can resume when it dies at 3am.

Ready when you are

Want to discuss this topic?

Start a Conversation