Grok 4.5: The Cursor-Trained Model Changes the Agent Cost Curve
Read xAI's own Grok 4.5 launch charts and an awkward fact jumps out: the new model does not win most of them.
It trails Fable 5 and GPT-5.5 on DeepSWE. It trails Fable 5 and Opus 4.8 on SWE-Bench Pro. On Terminal-Bench 2.1, it lands within a tenth of a point of GPT-5.5, but still behind Fable 5.
And yet Grok 4.5 may be one of July's more consequential model releases.
The reason is not a hidden benchmark crown. It is the operating point xAI is trying to sell: near-frontier coding, a claimed 80 output tokens per second, a 500,000-token context window, short-context pricing of $2 per million input tokens and $6 per million output tokens, and far lower reported output-token use on one difficult software benchmark.
Then xAI placed that model directly inside Grok Build, Cursor, Office add-ins, the API, and several infrastructure gateways.
That combination changes the question a serious buyer should ask. The question is no longer simply, "Which model posts the highest score?"
It is:
Which system completes the task
with acceptable quality,
in the least elapsed time,
for the lowest total cost,
with the least human cleanup?
Grok 4.5 is xAI's attempt to win that equation without winning every individual term. That makes it less like a universal intelligence trophy and more like a deliberately tuned workhorse.
Grok 4.5 did not arrive on one clean date. xAI's API release notes and Cursor's joint launch post place initial API and Cursor availability on July 8. xAI's detailed 23-page model card followed on July 14. The live SpaceXAI announcement and news index are dated July 16.
That chronology makes the July 16 public announcement the third documented step in the rollout, not the first moment developers could call the model.
The canonical API model is grok-4.5. xAI also documents grok-4.5-latest and grok-build-latest, but no Grok 4.5 Heavy, mini, multi-agent, or separate Fast API ID. Cursor does sell a surface-specific Fast tier at $4/M input and $18/M output; that is a Cursor serving option, not a separately documented xAI API model.
For reproducible evals, use grok-4.5, record the date and configuration, and avoid moving latest aliases. Even then, xAI does not publish a dated immutable 4.5 checkpoint, so a model name alone is not a full reproducibility record.
According to the model documentation, Grok 4.5 accepts text and images, returns text, supports the Responses and Chat Completions APIs, and can use function calling, structured outputs, web search, X search, and Python code execution. There is no official parameter count or maximum output-token figure. Elon Musk has reportedly described Grok 4.5 as a 1.5-trillion-parameter model, but xAI's formal launch post, developer docs, Cursor post, and model card do not document or substantiate that figure.
One documentation inconsistency belongs in the eval sheet: the developer overview gives a February 1, 2026 knowledge cutoff, while the model card says the pretraining cutoff was January 2026. Neither wording should replace live retrieval for current facts.
The cleanest way to understand Grok 4.5 is to look at all five headline coding charts together.
| Benchmark | Grok 4.5 | Leading result shown | Honest reading |
|---|---|---|---|
| DeepSWE 1.0 | 62.0 | Fable 5 — 66.1 | Strong, but behind Fable 5 and GPT-5.5 in the published chart. |
| DeepSWE 1.1 | 53 | Fable 5 — 70 | The largest visible gap among the five headline coding comparisons. |
| SWE Marathon | 29 | Grok 4.5 — 29 | Grok's clear launch-chart win, ahead of Opus 4.8 at 26 and Fable 5 at 24. |
| Terminal-Bench 2.1 | 83.3 | Fable 5 — 84.3 | In the leading cluster, only 0.1 behind GPT-5.5 in the shown results. |
| SWE-Bench Pro | 64.7 | Fable 5 — about 80.3 | Above GPT-5.5 in xAI's chart, but below Opus 4.8 and Fable 5. |
These values come from xAI's launch material and model card. They should not be averaged into a fictional "overall coding score."
The charts mix harnesses and sources. DeepSWE 1.0 uses provider harnesses run by Artificial Analysis. DeepSWE 1.1 uses a mini-swe-agent harness from Datacurve. Terminal-Bench runs Grok inside the Grok Build harness. Other numbers include provider-published or product-run results. Scaffolding, tool configuration, prompts, timeout policy, and repository setup can all move a score.
The correct conclusion is narrower: Grok 4.5 is in the frontier coding group, particularly for terminal and long-horizon software work, but xAI's own evidence does not establish it as the universal coding leader.
That is still meaningful. A production model does not need to lead every benchmark if it is fast enough, inexpensive enough, and reliable enough to produce more accepted work per dollar.
Cursor calls Grok 4.5 a jointly trained mixture-of-experts model. It says training included trillions of tokens of Cursor data capturing developer-agent, codebase, and tool interactions. xAI's model card uses a narrower formulation: supplemental training used anonymized Cursor workflow data to improve coding and agentic performance.
Those disclosures should be quoted precisely. They do not justify a claim that arbitrary private customer repositories became training data. Cursor's data-use policy says Privacy Mode data is not used for training; when Privacy Mode is off, prompts, codebase data, editor actions, and code snippets may be used.
The model card and launch material describe filtered data, supervised fine-tuning, reinforcement learning across hundreds of thousands of tasks, and agent trajectories that can run for hours. Those product-shaped environments target the sequence where benchmark-strong models often fail:
finding the right files
understanding project conventions
choosing the correct tool
recovering from a failed test
noticing an incomplete migration
keeping a long plan coherent
stopping before a destructive action
That gives xAI and Cursor a tighter loop:
workflow patterns
↓
agent training environments
↓
Grok 4.5 behavior
↓
Grok Build and Cursor distribution
↓
new evaluation and workflow signals
This may be more defensible than a temporary benchmark lead. A widely used coding surface can reveal where agents search badly, retry needlessly, or produce review-heavy diffs; a model partner can turn those failure patterns into training environments.
There is an important transparency detail too. Cursor excluded CursorBench because an earlier snapshot of Cursor's own codebase accidentally entered training, creating an unknown advantage. Excluding it was the right decision. It also shows why benchmark provenance belongs in model evaluation rather than in a footnote nobody reads.
The useful evaluation unit combines capability, token use, tool costs, elapsed time, retries, and human review.
A task enters with a repository, tool set, and harness. Grok 4.5 processes it at a chosen reasoning level. The application then crosses an economics layer: prompt length, cache state, paid tools, and priority processing. Finally, the work reaches a surface such as Grok Build, Cursor, an Office add-in, or a custom API product.
The output is not "a model response." The output is an accepted or rejected piece of work.
cost per accepted task =
model tokens
+ tool calls
+ retries
+ failed attempts
+ human review
+ latency cost
A leaderboard score measures only part of that equation. A token price measures another part. Neither tells you whether the model closes the ticket.
xAI reports 15,954 average output tokens on SWE-Bench Pro versus 67,020 for Opus 4.8 max—about one-quarter as many, which xAI describes as "4.2× fewer."
For agent systems, that can matter. Long software tasks amplify small inefficiencies as an agent plans, searches, calls tools, inspects results, revises, writes code, runs tests, and repairs failures. Fewer output tokens can mean lower generation cost, lower wall-clock time, less transcript state, and more tasks inside a fixed budget.
But the ratio needs two guardrails.
First, Grok scored 64.7% in that comparison while Opus 4.8 scored 69.2%. The outputs are not equal-quality units. A cheaper unsuccessful attempt is still a failure.
Second, output tokens are only one cost component. Input tokens, cache hits, paid tools, retries, human review, and competitor pricing all affect the result.
The evidence supports this statement:
Grok 4.5 appears unusually output-efficient in xAI's SWE-Bench Pro setup.
It does not yet support this one:
Grok 4.5 is always 4.2 times cheaper than Opus at equal quality.
One is a testable efficiency signal. The other is marketing arithmetic.
xAI's 80 TPS claim describes decode throughput: how quickly tokens arrive after generation begins. An agent user also feels time to first useful output—the delay before reasoning, retrieval, and setup produce anything visible—and then the much longer clock of total task completion.
Artificial Analysis's live Grok 4.5 page, checked July 16, reports 105.7 output tokens per second and 8.86 seconds to first answer token for the high-reasoning configuration. Its comparison views still place Grok below GPT-5.6 Luna and Gemini 3.5 Flash on raw output speed while ahead of several premium reasoners on first-answer latency. These live measurements can move as samples accumulate; they do not "correct" xAI's 80 TPS launch claim because the test conditions differ.
The evaluator's July 8 launch analysis reports 1.9 million average tokens per Coding Agent Index task, versus 7.2M for Fable 5 and 6.2M for GPT-5.5. That page is internally inconsistent on Grok's corresponding cost—one summary line says $2.59 while two detailed passages say $2.49—so the defensible shorthand is about $2.5 per task, versus $11.80 and $5.07. Those are harness-specific system estimates, not universal prices, but they independently point in the same direction as xAI's efficiency claim.
The useful latency dashboard therefore needs three rows:
time to first useful output
decode speed after generation begins
time to an accepted, verified result
Grok 4.5 does not need to be the fastest in every row. It needs the product of those clocks—and the failure rate—to beat the alternatives on your workload.
At the standard context tier, the official pricing page lists Grok 4.5 at $2/M input, $0.50/M cached input, and $6/M output. xAI's model detail page says requests that exceed 200K prompt tokens use the long-context rates of $4/M, $1/M, and $12/M.
Once a request is in the long-context tier, the higher rates apply to all tokens in the request; this is not a marginal surcharge on only the tokens above 200K.
| Example request | Token calculation | Model cost | What it shows |
|---|---|---|---|
| 100K input + 10K output | 100K × $2/M + 10K × $6/M | $0.26 | A substantial short-context request remains inexpensive before tools. |
| 250K input + 25K output | 250K × $4/M + 25K × $12/M | $1.30 | Exceeding 200K moves the entire request onto long-context rates. |
| 150K cached + 20K new + 10K output | 150K × $0.50/M + 20K × $2/M + 10K × $6/M | $0.175 | Stable cache routing can materially change agent-loop economics. |
Those examples exclude paid tools. xAI prices web search, X search, and code execution at $5 per thousand calls. Priority processing doubles token rates after cache discounts. Reasoning tokens bill at output rates.
Grok 4.5 is not currently accepted by xAI's Batch API, so do not build a migration case around an unavailable batch discount.
This turns prompt architecture into a financial decision. A team repeatedly sending a 250K-token repository snapshot may pay much more than one that retrieves relevant files, preserves stable prefixes, compacts old state, and keeps most requests below the threshold.
xAI strongly recommends a stable prompt_cache_key with the Responses API or an x-grok-conv-id header with Chat Completions. Without stable routing metadata, related requests may reach cache-cold workers and pay full input price. Cache hits are not guaranteed.
A production request might look like this:
const result = await client.responses.create({
model: 'grok-4.5',
input: task,
reasoning: { effort: 'medium' },
prompt_cache_key: 'repo:payments-service:policy-v12',
tools: approvedTools,
});
record({
model: 'grok-4.5',
accepted: await reviewer.accepted(result),
elapsedMs,
retries,
toolCalls,
usage: result.usage,
});
The key strategy depends on the product, but the principle is stable:
shared stable prefix → shared cache key
changed policy or repository baseline → new cache key
unbounded agent transcript → compact before it becomes the product
xAI's cost-tracking guide documents cost_in_usd_ticks in response usage as the exact billed cost for a request. Store it beside task outcome, latency, retry count, and review time. A monthly invoice tells finance what the model cost. Per-task telemetry tells engineering why.
The newer name does not make every older route obsolete.
Compared with Grok 4.3, Grok 4.5 cuts maximum context from 1 million to 500,000 tokens and raises listed short-context rates from $1.25/$2.50 to $2/$6. Past 200K, Grok 4.5 moves to $4/$12. It also lacks the documented batch path available to some older workloads.
In exchange, xAI offers stronger agentic behavior, the Cursor-shaped training loop, claimed 80 TPS generation, and better output efficiency in its highlighted coding test.
simple or high-volume request → cheaper model
huge-context retrieval task → model with the right context economics
difficult coding agent → evaluate Grok 4.5
strict batch workload → use a supported batch model
A model router is not premature optimization anymore. It is how a product avoids frontier rates for trivial work while preserving stronger capability when difficulty rises.
Multi-file repairs, terminal-heavy work, repository migrations, tool-rich debugging, and tasks where retries or slow generation already dominate the bill.
Use a cheaper model for classification, extraction, and routine edits, then escalate difficult tasks based on measured failure or complexity.
The 500K window is large, but the 200K pricing threshold makes retrieval, compaction, and competing long-context models worth testing.
Hold broad rollout if you require supported batch execution, independently validated reliability, or regional and procurement answers the current docs do not settle.
xAI also positions Grok 4.5 for knowledge work. Snorkel reports a 29% perfect pass rate on GDPval+ professional-work tasks, compared with 22% for GPT-5.5 and 21% for Opus 4.8. Its evaluation write-up focuses on producing artifacts rather than simply answering questions.
A seven-point lead is meaningful. So is the inverse: under the strict rubric, Grok 4.5 failed to earn a perfect pass on 71% of tasks.
The comparison is also a system result, not a sterile base-model duel. Grok ran through Grok Build while competing models used a different agent harness. Product scaffolding and execution policy are part of what was measured.
That does not make the evaluation useless. Buyers deploy systems, not disembodied weights. It does mean the result should be described accurately.
Grok 4.5 is confirmed in the API, the xAI console, Grok Build, Cursor, Office add-ins, and gateways including OpenRouter, Vercel, Cloudflare, Snowflake, and Databricks Mosaic. That is a short path from model release to real work.
Two rollout limits deserve careful wording.
First, the July 14 model card said consumer web, mobile, and Grok-in-X availability would come later. The July 16 xAI pricing page now lists Grok 4.5 as a $30/month SuperGrok entitlement, but xAI has not clearly documented a completed model-picker rollout across grok.com, mobile, and X. The formal sources confirm the API, Grok Build, Cursor, Office add-ins, and model gateways; for consumer access, verify the specific surface and account, and do not infer free-tier availability.
Second, xAI's developer documentation still lists the EU API console as unavailable and expected later in July. Verify that status before promising a European deployment date.
The launch is broad. It is not universal.
The July 14 model card is the best source for judging the release responsibly. It documents intended uses, training categories, benchmark methodology, safety evaluations, deployment safeguards, and limitations. It also says Grok 4.5 does not silently fall back to another model.
xAI reports 7.8% harmful compliance and 0% benign refusal on its internal HackerBench v0.2 with standard release-tracked safeguards, 0.73% jailbreak compliance, 1.1% general harmful compliance, and CBRN refusal accuracy of 97.9% for bio, 96.7% for chemical, and 97.9% for radiological/nuclear prompts. Its 80.4% CyberGym figure is an unrestricted capability probe with normal safeguards removed—not deployed harmful compliance.
Those figures need two labels: they are xAI-reported, and many use internal or vendor-defined evaluations. They are useful evidence, not independent replication. The card does not publish parameter count, training FLOPs, an external safety audit, or a dedicated loss-of-control evaluation section.
It also warns against autonomous high-stakes decisions in medicine, law, finance, and safety-critical systems without human oversight and domain-expert validation. That belongs in product requirements, not only legal review.
RohitAI has separately covered a reported Grok Build repository-upload path. That report concerns product behavior in a tested Grok Build configuration; it does not prove anything about Grok 4.5 training. The connection is narrower: once an agent receives source code, tools, network access, and permission to act, model evaluation and product-boundary evaluation are both required.
Do not recreate xAI's leaderboard. Recreate your workload. Use known outcomes, ugly edge cases, and the same repository snapshot, tool permissions, timeout, retry policy, and review rubric for every model.
One number should sit at the top of the dashboard:
accepted tasks per $100
Place median completion time beside it. Then show failure severity, human review minutes, and p95 cost. That dashboard will tell you more than a dozen launch charts.
For related thinking on agent economics, RohitAI's analysis of the GPT-5.6 Codex rate card and agentic credit pool reaches the same operational conclusion from a different pricing system: once models run multi-step work, the billing unit moves from tokens toward useful outcomes.
Model labs used to compete mainly on researchers, compute, and static datasets. Coding products add another asset: the sequence between prompt and accepted patch. Teams that understand where agents search badly, retry needlessly, lose instructions, or produce review-heavy diffs can build more realistic training environments.
That does not remove privacy and consent obligations. It makes precise disclosure and governance more important.
Historically, teams chose a fast cheap model for interaction and a slow strong model for difficult work. Grok 4.5 tries to collapse that split with a frontier-class agent model at a claimed 80 TPS.
If that throughput holds under real load and tool use, competitors will need to publish latency and token-efficiency evidence beside benchmark scores. Users feel waiting time. Finance feels wasted tokens. Both become model-quality attributes.
Large context windows encouraged a lazy architecture: put everything in the prompt. Grok 4.5's pricing makes that choice visible. Exceeding 200K doubles listed token rates for the request. Teams will rediscover retrieval, state compaction, stable prompt prefixes, and task-scoped repository views.
The best long-context product may not send the most context. It may know what not to send.
Grok 4.5 is not the benchmark king implied by the usual launch-day excitement. It is more interesting than that.
xAI has built a credible coding and agent model around a production thesis: give developers frontier-level capability, serve it quickly, reduce wasted output, price it aggressively below 200K context, and distribute it where work already happens.
The strongest evidence is the combination:
competitive coding scores
+ one clear long-horizon win
+ near-leading terminal performance
+ claimed 80 TPS serving
+ low reported output-token use
+ immediate product distribution
The weak spots are equally concrete:
not the leader on most headline coding charts
+ a sharp long-context pricing step
+ no current batch support
+ mixed benchmark harnesses
+ mostly vendor-reported safety evidence
+ incomplete consumer and regional rollout
That makes Grok 4.5 a model to evaluate, not a model to worship.
Teams running expensive coding agents should test it now. Teams doing simple high-volume work should route selectively. Teams with strict governance, batch, or regional requirements should confirm the product boundary before committing.
The practical question is not whether Grok 4.5 can produce an impressive demo. It is whether it can complete your work with fewer retries, less waiting, lower total cost, and an acceptable review burden.
If it does, xAI will not need first place on every chart.
Grok 4.5 is xAI's text-and-image model for coding, agentic tasks, and knowledge work. It supports a 500K context window, three reasoning levels, function calling, structured outputs, and xAI-hosted tools through the API.
xAI's pricing page now lists it as a SuperGrok entitlement, while the model card said consumer web, mobile, and X availability would come later. xAI has not clearly documented a completed rollout across every consumer model picker, so verify the surface and account rather than assuming universal access.
Through 200K prompt tokens, rates are $2/M input, $0.50/M cached input, and $6/M output. Above 200K, they become $4, $1, and $12 respectively for the full request. Tools and priority processing cost extra.
xAI's evidence does not establish that. Grok 4.5 wins SWE Marathon and performs near the leaders on Terminal-Bench 2.1, but trails other models on several DeepSWE and SWE-Bench Pro comparisons. The best model depends on your harness, repositories, tools, latency needs, and review standard.
xAI says the model was trained alongside Cursor, and its model card says supplemental training used anonymized Cursor workflow data. Cursor describes a jointly trained MoE using product-shaped data about codebase and tool interactions. That gives the training process examples of agent execution rather than only isolated code questions.
Not currently. xAI's Batch API documentation lists Grok 4.5 as unsupported. Teams that rely on batch discounts or asynchronous bulk jobs should keep a supported model route.
No. Requests exceeding 200K prompt tokens move onto higher rates for all tokens in the request. Retrieval, compaction, and stable caching can be cheaper and easier to evaluate.
No. xAI's model card advises against autonomous high-stakes decisions in those areas without human oversight and domain-expert validation. Treat it as an accelerator for reviewed work, not accountable authority.