Grok 4.5 in 2026: 1.5T Model Trained on Cursor Data

xAI dropped Grok 4.5 on July 8, 2026, and the coding-agent economics changed overnight. The headline isn’t just another benchmark win — it’s that this 1.5-trillion-parameter Mixture-of-Experts model hit 83.3% on Terminal-Bench 2.1 while spending roughly a quarter of the output tokens Claude Opus 4.8 burns on the same tasks. For anyone running autonomous coding agents at scale, output tokens are the bill, and Grok 4.5 just rewrote the per-task math. If you build with LLMs and haven’t re-run your cost model this week, you’re quoting stale numbers.

What’s actually new about Grok 4.5

Grok 4.5 is xAI’s newest frontier model, a sparse Mixture-of-Experts (MoE) architecture with 1.5 trillion total parameters and a much smaller active-parameter count per forward pass. That sparsity is the whole trick: you get the knowledge capacity of a giant dense model without paying to activate all of it on every token. MoE isn’t new, but xAI paired it with a training decision that is genuinely novel at this scale.

The model was trained on Cursor interaction data — real developer sessions inside the Cursor editor, including the accept/reject/edit loop that follows every AI suggestion. Most coding models learn from static repositories: finished code that never shows the messy path to “done.” Cursor data captures the reasoning trace of actual engineers steering an agent — which completions got kept, which got thrown away, how humans phrase follow-up instructions. That signal teaches the model to be decisive and terse instead of padding answers with hedging and restated context. It’s the leading theory for why Grok 4.5’s token efficiency is so far ahead of the pack.

The proof is in the Grok 4.5 benchmarks. On Terminal-Bench 2.1 — a hard agentic suite that scores a model on completing real command-line and repository tasks end to end — Grok 4.5 posted 83.3%. That alone puts it at the frontier. The efficiency figure is what makes it disruptive: on comparable coding tasks, xAI reports the model consuming roughly 25% of the output tokens Claude Opus 4.8 needs to reach a similar result. Same job, one-quarter the emitted tokens, and output tokens are where the money and the latency live.

Why Grok 4.5’s token efficiency matters

• Per-agent-task cost collapses. If your bill is dominated by output tokens — and for agentic coding it almost always is — a 4x efficiency gain is a near-4x cost cut before you even compare sticker prices. That changes which workloads are economical to automate at all.
• Fewer tokens means lower latency. Autonomous agents generate long action-observation loops. Emitting a quarter of the tokens per step means faster iterations, shorter feedback cycles, and agents that feel responsive instead of sluggish.
• The Grok 4.5 vs Opus 4.8 comparison is no longer a walkover for incumbents. Claude Opus 4.8 remains a top-tier reasoning and coding model, but “it’s the obvious default” is now a claim you have to defend on price-per-task, not just raw capability.
• Training-data provenance becomes a competitive moat. Cursor-style interaction data — the human-in-the-loop editing signal — is scarce and hard to replicate. Expect every serious lab to chase editor-integration data deals, and expect that to reshape editor partnerships.
• Longer, cheaper agent runs get unlocked. Tasks you’d never let an agent attempt because the token spend was unbounded — large refactors, multi-file migrations, deep test-generation sweeps — move back inside the budget.
• Your evals need refreshing. Terminal-Bench 2.1 is now a load-bearing number in the industry. If your internal benchmarks still weight only single-file completion, they’re measuring the wrong thing for the agent era.

How to use Grok 4.5 today

1. Get an xAI API key. Sign in at the xAI developer console, create a key, and export it. The API is OpenAI-compatible, so most existing tooling works with a base-URL swap.

   export XAI_API_KEY="xai-your-key-here"

2. Make your first call with curl. Point the standard chat-completions shape at the xAI endpoint and select the grok-4.5 model.

   curl https://api.x.ai/v1/chat/completions \
     -H "Authorization: Bearer $XAI_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "model": "grok-4.5",
       "messages": [
         {"role": "system", "content": "You are a terse senior engineer. Return code, not prose."},
         {"role": "user", "content": "Write a Python function that retries an HTTP GET with exponential backoff."}
       ]
     }'

3. Use the OpenAI SDK by overriding the base URL. No new client library required — this is the fastest path to migrate an existing codebase.

   from openai import OpenAI
   
   client = OpenAI(
       api_key="xai-your-key-here",
       base_url="https://api.x.ai/v1",
   )
   
   resp = client.chat.completions.create(
       model="grok-4.5",
       messages=[
           {"role": "system", "content": "Be decisive. No hedging, no restating the question."},
           {"role": "user", "content": "Refactor this loop into a vectorized NumPy call."},
       ],
   )
   print(resp.choices[0].message.content)

4. Prompt it to play to its strengths. Grok 4.5 was tuned on the human editing loop, so it rewards terse, action-oriented instructions. Tell it to skip preamble and it will — which is exactly where the token savings come from.

   System: You are an autonomous coding agent. Rules:
   - Emit only the changed code and a one-line rationale.
   - Do not restate the task or explain what you are about to do.
   - If a command is needed, output it in a fenced block, nothing else.

5. Wire it into your agent harness. If you run an agentic loop, set Grok 4.5 as the executor model and measure output tokens per resolved task, not per API call. That’s the metric where the efficiency shows up.

   # pseudo-config for an agent runner
   executor:
     provider: xai
     model: grok-4.5
     base_url: https://api.x.ai/v1
     max_output_tokens: 8000
     stop_on_task_complete: true
   metrics:
     track: [output_tokens_per_resolved_task, wall_clock_per_task]

6. Benchmark it against your own workload before committing. Public Grok 4.5 benchmarks are a signal, not a guarantee. Run a representative sample of your tasks through both Grok 4.5 and your incumbent, and compare cost-per-resolved-task and quality side by side.

How it compares

The headline matchup is Grok 4.5 vs Opus 4.8, but the token-efficiency story is what reframes the whole field. The table below summarizes the publicly reported positioning at launch — treat the pricing and efficiency columns as the numbers to verify against your own runs.

Model	Architecture	Terminal-Bench 2.1	Relative output tokens (coding)	Notable trait
Grok 4.5 (xAI)	1.5T MoE (sparse)	83.3%	~1x (baseline — most efficient)	Trained on Cursor interaction data
Claude Opus 4.8 (Anthropic)	Frontier dense/hybrid	Frontier-tier	~4x Grok 4.5 on comparable tasks	Deep reasoning, long-horizon coding
Prior-gen general models	Varies	Lower	High	Weaker agentic completion

The takeaway isn’t “Grok 4.5 beats everything.” Opus 4.8 is still an exceptional model, and for the hardest long-horizon reasoning many teams will keep it in the loop. The takeaway is that Grok 4.5 pricing — measured the honest way, in dollars per resolved task rather than dollars per million tokens — is now competitive enough that the xAI coding model deserves a slot in your bake-off instead of an automatic pass.

What’s next for xAI’s coding model

The most important thing to watch is whether the Cursor-data advantage holds up outside the benchmark. Interaction-trained models can look spectacular on suites that resemble their training distribution, then wobble on genuinely novel repositories or unusual toolchains. The next month of independent, third-party evaluations — people running Grok 4.5 on their own private codebases — will tell us whether 83.3% on Terminal-Bench 2.1 translates into 83.3%-quality behavior on your Tuesday-afternoon bug.

Expect the rest of the industry to respond on two fronts. First, pricing: incumbents will feel pressure to cut per-token costs or ship their own efficiency-focused variants, because “we’re smarter but 4x more expensive per task” is a hard sell to a CFO watching an agent bill. Second, data: if Cursor-style human-editing signal is the ingredient that produced this efficiency, every major lab will race to secure comparable editor-integration data, which likely means new partnerships — and new scrutiny over who owns the interaction traces developers generate.

For your own roadmap, the practical move is to treat Grok 4.5 as a live option, not a headline. Add it to your model router, gate it behind quality checks, and let cost-per-resolved-task decide where it wins. The models will keep leapfrogging; the teams that win are the ones with the evaluation harness to switch quickly when one does.

Frequently Asked Questions

What is Grok 4.5?

Grok 4.5 is xAI’s frontier language model released on July 8, 2026. It’s a 1.5-trillion-parameter Mixture-of-Experts model trained partly on Cursor developer-interaction data, and it’s aimed squarely at agentic coding workloads.

How did Grok 4.5 do on the benchmarks?

The standout Grok 4.5 benchmark is 83.3% on Terminal-Bench 2.1, a demanding agentic suite that scores end-to-end completion of real command-line and repository tasks. Paired with its token efficiency, that places it at the coding frontier.

How does Grok 4.5 compare to Opus 4.8?

On the Grok 4.5 vs Opus 4.8 question, both are top-tier, but Grok 4.5’s edge is efficiency: xAI reports it using roughly 25% of the output tokens Opus 4.8 needs on comparable coding tasks. Opus 4.8 remains extremely strong on deep, long-horizon reasoning, so the right choice depends on whether your bottleneck is cost-per-task or hardest-case capability.

Why does token efficiency matter so much?

For agentic coding, output tokens dominate both cost and latency. A model that emits a quarter of the tokens to finish the same task is close to 4x cheaper and faster per task before you even compare list prices — which is why Grok 4.5 pricing looks so aggressive when measured per resolved task.

What does “trained on Cursor data” actually mean?

The model learned from real developer sessions in the Cursor editor — the accept, reject, and edit decisions engineers make as they steer an AI. That human-in-the-loop signal is the leading explanation for why this Cursor-trained AI model is so terse and decisive, and therefore so token-efficient.

How do I start using Grok 4.5?

Grab an xAI API key, then call the OpenAI-compatible endpoint at https://api.x.ai/v1 with the model set to grok-4.5. Existing OpenAI-SDK code works with just a base-URL and key swap, so most teams can trial it in an afternoon and benchmark it against their current model on their own tasks.