Grok 4.5: The Cursor-Trained Model Changes the Agent Cost Curve

Rohit Ramachandran

Jul 16, 2026Updated Jul 16, 2026

• ai
• xai
• grok
• grok-4-5
• coding-agents
• cursor
• developer-tools
• model-pricing

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.

A release in three acts

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 benchmark chart does not say what the launch copy wants you to feel

The cleanest way to understand Grok 4.5 is to look at all five headline coding charts together.

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 is part of the model story, not just a launch partner

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 production equation behind Grok 4.5

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.

Why 15,954 output tokens may matter more than $6 per million

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.

Agent speed has two clocks

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.

The $2/$6 price has a 200K-token trapdoor

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.

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.

Caching is an application responsibility

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.

Grok 4.5 is a routing model, not an automatic Grok 4.3 replacement

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.

The professional-work result is encouraging—and still mostly failure

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.

Distribution may be xAI's second advantage

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.

What the model card adds beyond the launch post

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.

How I would evaluate Grok 4.5 before routing real work to it

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.

Three predictions from this launch

1. Product telemetry becomes part of the frontier-model moat

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.

2. “Fast model” and “smart model” become the same buying category

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.

3. The 200K threshold makes context engineering visible again

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.

My verdict

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.

Frequently asked questions

What is Grok 4.5?

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.

Is Grok 4.5 available in the consumer Grok app?

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.

How much does the Grok 4.5 API cost?

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.

Is Grok 4.5 the best coding model?

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.

Why does Cursor matter to Grok 4.5?

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.

Does Grok 4.5 support batch processing?

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.

Should I always use the 500K context window?

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.

Is Grok 4.5 safe for autonomous financial, medical, or legal decisions?

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.