Grok 4.5 Guide: xAI's Turn Towards Agentic Coding

Grok 4.5 is where the Grok line changed direction. The earlier 4.20 and 4.3 models were pitched as fast, general tool-callers with 1M-token windows. Grok 4.5, announced on 16 July 2026, is pitched as a coding and agentic model first, with a smaller window, a higher price, and a training run built around multi-step software engineering.

A note on names: xAI, the company behind Grok, was renamed SpaceXAI in July 2026 after SpaceX acquired it. This guide uses the xAI name throughout.

It has since been followed by Grok 4.6 and Grok 4.7 at the same headline price. So the useful questions are what 4.5 changed, how much of its pitch holds up, and whether there is any reason to pin it now.

What changed with Grok 4.5

xAI describes Grok 4.5 as its model for coding, agentic tasks and knowledge work, and says it was trained alongside Cursor. The announcement attributes the gains to new data covering coding, science, engineering and maths, and to reinforcement learning across hundreds of thousands of tasks centred on multi-step software engineering, graded both automatically and by models. It also describes an asynchronous training stack so agentic rollouts can run for many hours.

The API-level changes are what you will notice first:

• Context drops to 500,000 tokens, half of Grok 4.3's 1M.
• Price rises to $2.00 per million input tokens, $0.30 cached and $6.00 output, under the 200K-token tier.
• Reasoning defaults to high, where Grok 4.3 defaults to low. There is no none option.
• Batch is not supported.
• Rate limits rise to 150 requests per second and 50 million tokens per minute at the time of writing.

One small inconsistency in xAI's docs: the model page lists xhigh as a supported effort, but the reasoning guide says xhigh only applies from Grok 4.6 onwards and is treated as high on Grok 4.5. Assume the latter and do not pay for an effort level you are not getting.

As with every Grok model so far, there are no open weights and no published parameter count.

Benchmarks, read carefully

xAI's launch table is vendor-reported, with competitor figures taken from system cards and public leaderboards:

• SWE-Bench Pro: 64.7%, third in the table, behind Fable at 80.4% and Opus 4.8 at 69.2%.
• Terminal-Bench 2.1: 83.3%, third, a fraction behind GPT 5.5 and Fable.
• DeepSWE 1.0: 62.0% (third); DeepSWE 1.1: 53% (fourth).
• SWE Marathon: 29.0%, first in the table.

That is an honest-looking table: it shows Grok 4.5 behind on most rows, and the one first place is on SWE Marathon, where every model in the table scores below 30%. The pattern suggests a model that is competitive rather than leading, with a particular claim on long runs.

The usual caveats apply. Different rows use different harnesses, the competitor figures were not all produced under the same conditions, and vendor tables tend to flatter the vendor. Vendor-claimed vs independent benchmarks covers how to weigh them. On the Artificial Analysis Intelligence Index, xAI's later Grok 4.6 announcement lists Grok 4.5 at 56.

Token efficiency is the claim to test

The most commercially interesting claim is not a score. xAI says that on SWE-Bench Pro, Grok 4.5 averaged 15,954 output tokens per task against 67,020 for Opus 4.8 at max effort, roughly 4.2 times fewer, and that it solves tasks in under half the steps of comparable models. It also quotes around 80 tokens per second of output.

If that holds on your work, it changes the price comparison completely. A model at $6 per million output tokens that uses a quarter of the output is far cheaper per completed task than its rate card suggests. If it does not hold, you are paying a mid-tier price for mid-tier results.

This is cheap to check. Run the same twenty agentic tasks through Grok 4.5 and your current model, using the same harness and the same starting state. Record output tokens, turns and pass or fail for each. Then divide total cost by tasks passed. How to benchmark LLMs on your own work has the setup.

Half the context of Grok 4.3

The window cut is the trade that matters most for long-document work. Anything between 500K and 1M tokens simply will not fit, and the 200K billing threshold still applies: at or above it, every token in the request is billed at $4 input and $12 output.

For coding agents this is rarely binding, because a well-run agent retrieves files rather than loading the whole repository. For document analysis and long transcripts it can be. If your prompts routinely exceed 500K, stay on Grok 4.3, or summarise and compact the context before it grows past the limit.

Why you might still pin Grok 4.5

Grok 4.6 and 4.7 are listed at the same $2 input and $6 output. So 4.5 is mostly a model you migrate away from. There are two narrow reasons to keep it:

• Cheaper cached input. Grok 4.5 lists cached input at $0.30 per million tokens; 4.6 and 4.7 list $0.50. For an agent loop that re-reads a long cached prefix every turn, that difference is real. The Grok 4.6 guide works through the arithmetic.
• A validated pipeline. If your evaluations were built against 4.5 and it meets the bar, re-validating has a cost too.

Otherwise, test the newer models first. Grok 4.6 reports gains over 4.5 on every row of its own launch table.

Checklist before adopting it

1. Confirm your prompts fit under 500K, and ideally under 200K.
2. Set effort explicitly. The default is high, which is the expensive end.
3. Measure output tokens per completed task, not just pass rate.
4. Compare cached-input-heavy workloads against Grok 4.6 at its higher cache rate.
5. Keep a cheaper model in the routing path for tasks that do not need it.