Grok 4.5 is not mainly a leaderboard story. At $2 input and $6 output per million tokens, it is a signal that closed frontier models are getting cheaper without becoming open source.
Share This Report
Copy the link, post it, or save a PDF version.
Grok 4.5 launched on July 8, 2026 at $2 per million input tokens and $6 per million output tokens, and that price matters more than whether it tops any leaderboard today. The useful read on Grok 4.5 is not "xAI beat Anthropic" or "Cursor built a better coding model." The useful read is narrower and more durable: a closed model can now be priced like a volume product while still being sold as a serious agent model.
That is a different future from the one the open-weight camp has been selling.
For the last two years, the usual bargain was simple. If you wanted low cost and control, you looked at open weights. If you wanted the frontier, you paid proprietary pricing and accepted the vendor's API, roadmap, and policy surface. Grok 4.5 pushes on that split. It is closed, API-first, available through Cursor, and cheap enough that a buyer can at least ask whether open weights are still the only path to lower inference bills.
This post is deliberately not a victory lap. Elon Musk framed the model in a July 8 post on X as roughly Opus-class, faster, and cheaper, then added the sentence that matters: "real-world usefulness, not benchmarks." Cursor's launch post does publish benchmark numbers, and they are useful. They are not enough for BenchLM to rank the model yet.
We are not going to invent a score to make launch day tidy.
The official xAI model page lists grok-4.5 as a reasoning model with text and image input, text output, function calling, structured outputs, and a 500K-token context window. It also lists aliases grok-4.5-latest and grok-build-latest, with deployment regions in us-east-1 and us-west-2.
The pricing is the part to stare at:
| Item | Grok 4.5 |
|---|---|
| Input tokens | $2.00 / million |
| Cached input tokens | $0.50 / million |
| Output tokens | $6.00 / million |
| Context window | 500K tokens |
| Input modalities | Text, image |
| Output modality | Text |
| Model type | Closed, proprietary API |
xAI also notes higher context pricing above 200K tokens. That matters for long-agent loops, but the sticker price is still the launch signal. A buyer can route ordinary work to a closed model at $2/$6 and reserve more expensive models for tasks where the quality delta survives measurement.
The official xAI launch post adds the operational part of the price story. It says Grok 4.5 is served at 80 tokens per second, reaches roughly 2x the token efficiency of comparable leading models, and uses 15,954 output tokens on average per SWE-Bench Pro task versus 67,020 for Opus 4.8 max. That is xAI's 4.2x-fewer-token claim.
xAI also says Grok 4.5 is the default model in Grok Build, available through the SpaceXAI console, and not yet available in the EU, with EU availability expected in mid-July 2026. That last detail matters for procurement more than leaderboard charts do.
Cursor adds another commercial layer. Its launch post says Grok 4.5 is available across desktop, web, iOS, CLI, and SDK, with significant usage included in individual and team plans and doubled usage for the first week. Cursor also names a fast variant priced at $4 input and $18 output per million tokens.
Cursor also clarified in a July 8 post that Grok 4.5 and Composer are different model weight classes. That matters for how to read the partnership. Grok is not Composer 3 under a new name, and it is not a clean replacement for Composer 2.5.
The more likely product shape is a two-lane first-party model pool: Grok 4.5 for heavier, broader, longer-running work; Composer for the smaller coding-specialist lane. Cursor says Composer 2.5 will remain offered and that it will release new models of that size going forward. So buyers should still expect the Composer-sized line to continue, even if Grok gets the launch-day attention.
So the launch is not just "a model exists."
It is a distribution bundle: Cursor users get the model inside the tool where agentic coding work already happens, while API buyers get a price that reads more like a production tier than a trophy tier. That is how closed models become infrastructure. Not by winning every benchmark. By becoming cheap enough to leave on.
The official xAI launch post adds a fuller benchmark chart than Cursor's launch table. Cursor is still useful because it includes Composer 2.5 and SWE-Bench Multilingual, but xAI's post adds DeepSWE 1.1, GLM 5.2 on two rows, and the SWE-Bench Pro token-efficiency claim.
| Benchmark | Grok 4.5 | Fable 5 | GPT-5.5 | Opus 4.8 | GLM 5.2 | Composer 2.5 |
|---|---|---|---|---|---|---|
| DeepSWE 1.0 (provider harness) | 62.0% | 66.1% max | 64.31% xhigh | 55.75% max | - | 18.0% |
| DeepSWE 1.1 (DataCurve mini-swe-agent) | 53.0% | 70.0% max | 67.0% xhigh | 59.0% max | 44.0% | - |
| Terminal-Bench 2.1 | 83.3% | 84.3% | 83.4% xhigh | 78.9% max | - | 73.0% |
| SWE-Bench Pro resolve rate | 64.7% | 80.4% max | 58.6% xhigh | 69.2% max | 62.1% | 54.0% |
| SWE-Bench Multilingual (Cursor) | 78.0% | - | 77.8% | 84.4% | - | 71.6% |
The table is mixed-source by design. DeepSWE 1.0, DeepSWE 1.1, Terminal-Bench 2.1, SWE-Bench Pro, GLM 5.2, and the 80.4% Fable SWE-Bench Pro row come from xAI's official chart. Composer 2.5 and SWE-Bench Multilingual come from Cursor's launch post. That is the cleanest way to preserve both pieces of evidence without pretending the two posts published the same comparison set.
Those rows say three things at once.
First, Grok 4.5 is clearly in the serious-model conversation. An 83.3% Terminal-Bench 2.1 score sitting almost exactly beside GPT-5.5 and one point behind Fable 5 is not a toy result. SWE-Bench Multilingual at 78.0% is also strong enough to treat the model as more than a narrow English coding assistant.
Second, the table does not say Grok 4.5 is the best coding model. Fable 5 leads DeepSWE 1.0, DeepSWE 1.1, Terminal-Bench 2.1, and SWE-Bench Pro. Opus 4.8 leads the multilingual row and beats Grok 4.5 on DeepSWE 1.1. GPT-5.5 is also ahead of Grok on both DeepSWE rows. The pattern is competitive, not dominant.
Third, the caveats are unusually important. xAI labels DeepSWE 1.0 as within each model provider's harness and DeepSWE 1.1 as a DataCurve mini-swe-agent harness run. Cursor says SWE-Bench Pro and Terminal-Bench show self-reported scores for third-party models. It says the GPT-5.5 SWE-Bench Multilingual score comes from an internal run. It also says Grok 4.5 has an advantage on CursorBench because an earlier Cursor codebase snapshot was accidentally included in training, so Cursor excludes that benchmark while it updates the suite.
That last sentence is the most BenchLM sentence in the whole launch.
The official post also says Grok 4.5 scores #1 on Harvey's Legal Agent Benchmark. That may be meaningful for office and legal-agent work, but the post does not expose a visible score in the text we can map. BenchLM should treat it as a launch claim, not a ranked row.
The benchmark chart is useful evidence. It is not a license to put Grok 4.5 into a verified ranking before the rows are mapped, sourced, and normalized against the same rules as everyone else. Our model page for Grok 4.5 tracks the release; the verified score waits for verified data.
The strategic fact is not that Grok 4.5 is cheap in an absolute sense. Open-weight and small proprietary models can be cheaper. The strategic fact is that Grok 4.5 is cheap for the class of product it is trying to be: a broad, tool-using, long-context, closed model distributed through a coding agent platform.
That matters because price compression changes deployment behavior.
When a model is expensive, teams route it sparingly. They build classifiers in front of it. They shorten prompts. They trim context. They tell agents to stop early. They keep the expensive model for final review or high-stakes branches, while cheaper models do the dull work. That architecture can be correct, but it has a hidden cost: every routing rule is another way to fail.
When a model gets cheaper, teams do fewer clever things.
They let the model read the file twice. They allow the planning pass. They keep more context in the loop. They retry a failed tool call instead of escalating. They can run the same evaluation prompt across more candidate outputs. They can put an agent into a slower, more deliberate mode for work that previously would have been too expensive to automate.
At $2/$6, Grok 4.5 is not free. A runaway agent can still turn a weekend into an invoice. But it sits in a range where more teams can use a capable closed model as a default worker instead of a special occasion model. Cached input at $0.50 per million tokens makes that more interesting for repeated repository, policy, or documentation context.
That is why the open-source comparison matters commercially. Open weights have always had three practical arguments: control, inspectability, and cost. Grok 4.5 does not answer control or inspectability. It does press directly on cost. If a closed vendor can make the hosted version cheap enough, a large slice of buyers will choose the managed product and accept that they cannot touch the weights.
The buyer's spreadsheet is not sentimental.
Closed-model vendors used to defend high prices with a simple story: frontier training is expensive, inference is expensive, safety work is expensive, and the premium API bill funds the next jump. Open-weight vendors and labs answered with a different story: if the community can run the model, distill it, quantize it, and deploy it anywhere, the market will force price down.
Grok 4.5 points to a third path. Keep the weights closed. Sell the model through an API and first-party product surfaces. Drop the price anyway.
That path is powerful because it gives the vendor several advantages at once. xAI keeps operational control over the model. Cursor gets a differentiated first-party model inside its product. Customers get lower per-token prices without running inference infrastructure. The model can be updated, safeguarded, throttled, and bundled without asking the market to coordinate around a public checkpoint.
For users who need local deployment, data isolation, or weight-level auditability, that is not enough. They should keep looking at open-weight systems, private deployments, or vendors willing to sign the right infrastructure terms. Grok 4.5 does not make open weights obsolete. It makes one open-weight argument less automatic.
The weaker version of the open-weight pitch is "it is cheaper." That argument gets less stable whenever a closed vendor drops price. The stronger version is "we can control, inspect, modify, and survive vendor policy changes." Grok 4.5 does not touch that. It just forces the open side to argue from the stronger ground.
Good. The stronger ground was always the point.
Musk's tweet is easy to flatten into a benchmark dispute, but the sentence about real-world usefulness is the better lens. A model becomes useful when it appears in the workflow, stays fast enough to tolerate, and costs little enough that users do not ration every call.
That is why Cursor matters here.
Grok 4.5 did not launch as a PDF with a benchmark table waiting for framework authors to wire it in. It launched inside a coding environment, with desktop, web, iOS, CLI, and SDK access. Cursor says the model was trained jointly with SpaceXAI, using trillions of tokens of Cursor data that capture user interactions with codebases and software tools. It also says the training mix was broader than Composer 2.5, adding STEM tasks, research papers, and knowledge work.
We should be careful with that claim. Training on product data can make a model feel unusually good inside the product and less obviously superior outside it. Cursor's own CursorBench caveat is exactly the kind of contamination warning that should make readers slow down. Still, the product strategy is coherent: build the model where agent loops are already observed, then ship it back into the same loop.
That is the "real-world usefulness" flywheel. The model improves inside the product. The product gives it distribution. Distribution generates more task traces. More task traces shape the next model and the next harness. Open-weight labs can do some of this through community telemetry and public evals. A tightly integrated product vendor can do it with lower friction.
The risk is obvious too. Product-specific training can create models that ace the home environment and disappoint in neutral settings. It can also create benchmark blind spots if evaluation data, codebase snapshots, or agent traces leak into training. Cursor's public caveat lowers that risk by naming it, but naming the problem does not delete the problem.
For BenchLM, the rule is simple: product evidence is evidence of product fit, not general ranking evidence.
If you are already using Cursor heavily, Grok 4.5 is worth testing immediately on long-running coding and tool-use tasks. The right evaluation is not a generic chat prompt. Use tasks that burn real time: migrate a messy module, chase a failing integration test, write a data cleanup script, update a multi-file API surface, or investigate an issue with incomplete logs. Measure task completion, human intervention, wall-clock time, and token cost.
If you buy models through API routing, put Grok 4.5 into the value lane, not the crown-jewel lane. Compare it against the models you currently use for high-volume engineering support, internal analysis, codebase Q&A, and tool-using agents. The price target is the reason to test it. The failure mode is quality variance on tasks where your existing top model still pays for itself.
If you run open weights for cost reasons only, rerun the math. Include infrastructure, utilization, engineering time, batch size, latency targets, and the cost of model maintenance. A hosted $2/$6 closed model may be cheaper than a self-hosted stack once the real bill includes the humans keeping it alive.
If you run open weights for control reasons, Grok 4.5 changes less. Keep your open deployment, but use Grok as a useful comparator. If the closed model wins on a task you care about, ask whether that task actually required local control. If it loses, you have a stronger reason to keep the stack you already maintain.
The one thing not to do: switch because a launch table has a bigger number in one row. Cursor's table is mixed. The caveats are material. The price is the signal.
BenchLM has added Grok 4.5 as a tracked model with pricing, context, modality, and release metadata. The row is intentionally not ranking eligible yet. The reason is not skepticism about xAI. It is the same rule we apply to everyone: weighted rankings need mapped benchmark rows with citable sources for the exact model variant.
There are already useful signals. xAI's launch chart gives Terminal-Bench 2.1, DeepSWE 1.0, DeepSWE 1.1, SWE-Bench Pro, token efficiency, and latency claims. Cursor adds SWE-Bench Multilingual and Composer comparison rows. xAI's docs give price, cached input, context, aliases, regions, and feature flags. Musk's public framing gives the intended market position: comparable capability, faster speed, lower cost, and usefulness over benchmark theater.
But "useful signal" is not the same as "verified leaderboard row."
What would change the status? Primary benchmark results for Grok 4.5 on the exact variant xAI serves through the API, enough coverage to map into BenchLM's weighted categories, and evidence that the public model is the one being evaluated. If those land, we will rank it. If they do not, we will keep the model visible without pretending the blanks are numbers.
This is the same argument we made in What AI Labs Don't Publish: missing data is itself data. The difference here is that Grok 4.5 has enough product and pricing evidence to matter before the benchmark picture is complete.
Grok 4.5 is a bet that the next phase of frontier competition is not only about who has the highest peak score. It is about who can sell enough useful intelligence at a low enough price, inside a workflow sticky enough that switching feels expensive.
That is a colder market than the benchmark market.
Benchmarks reward the best visible number. Production rewards the model that finishes the task, appears where the user already works, returns fast enough, and does not make finance shut the project down. A model can lose a few benchmark rows and still win volume if it is cheap, fast, and integrated. A model can top a benchmark and still lose deployment if the access terms, latency, or price make it annoying to use.
Grok 4.5 also shows how closed labs can borrow one of open source's best commercial weapons without giving up weights. They can lower price. They can bundle usage. They can expose cached-token discounts. They can distribute through a product with real task data. They can make the closed option feel operationally easy enough that many teams stop asking for the checkpoint.
That does not kill open source. It sharpens the question open source has to answer. Not "are you cheaper than the most expensive closed model?" but "what do you let me control that a cheap closed API still withholds?"
For the market, that is healthy. For buyers, it is annoying in the useful way: the decision gets more specific. You no longer get to say open equals cheap and closed equals best. Grok 4.5 is closed, cheap, and plausibly strong enough to test. That combination is the future signal.
The next number to watch is not one benchmark score. It is how many serious agent workloads can move to $2/$6 closed inference without users noticing a quality tax.
Grok 4.5 matters because xAI is selling a closed, tool-capable model at $2 input and $6 output per million tokens, not because it has already proven a BenchLM ranking win. The launch points toward cheaper proprietary frontier access without an open-weight release.
No. xAI's public model documentation presents Grok 4.5 as an API model, not an open-weight release. That is the strategic point: xAI is using price, speed, Cursor distribution, and tool capability to compete while keeping the model weights closed in this release.
xAI lists Grok 4.5 at $2 per million input tokens, $0.50 per million cached input tokens, and $6 per million output tokens. Cursor's launch post also names a faster variant at $4 input and $18 output per million tokens at launch.
No. Cursor says Grok 4.5 and Composer are different model weight classes, Composer 2.5 will remain offered, and new models of that size are still planned. The practical read is two lanes: Grok for heavier broad work, Composer for smaller coding-specialist work.
Not as a clean public verdict. xAI reports Grok 4.5 at 83.3% on Terminal-Bench 2.1, 62.0% on DeepSWE 1.0, 53% on DeepSWE 1.1, and 64.7% on SWE-Bench Pro. Cursor adds SWE-Bench Multilingual at 78.0%. BenchLM has not ranked it yet.
BenchLM needs exact, citable benchmark rows before a model enters the verified ranking. Grok 4.5 has pricing, context, modality, and launch benchmark signals, but not enough mapped primary benchmark data in BenchLM's weighted set. We track it without inventing a score.
New models drop every week. We send one email a week with what moved and why.
Share This Report
Copy the link, post it, or save a PDF version.
On this page
Which models moved up, what’s new, and what it costs. One email a week, 3-min read.
Free. One email per week.
For two years, no AI model crossed 50% on Humanity's Last Exam. As of July 2026, fourteen models have, and the top tool-assisted score is 64.5. What broke the ceiling matters as much as the number.
BenchLM added ResearchClawBench as a display-only benchmark. Claude Code leads at 21.5 RADS, far below the 50-point paper-reproduction line.
A reader caught BenchLM ranking Qwen3.7 Max below its own cheaper sibling. The bug was not a data error. It was the averaging method almost every LLM leaderboard uses, and fixing it moved 170 scores.